peachsim 0.1.1644 → 0.1.1653

package/kotlin/fixtures/runtime-state/RuntimeState.kt

@@ -1,200 +0,0 @@
-package dev.contrast.composefixtures
-
-import dev.onejs.one.source.OneModule
-import androidx.compose.runtime.*
-import androidx.compose.runtime.snapshots.Snapshot
-import kotlinx.coroutines.*
-import org.json.JSONObject
-
-private class Node {
-    var text = ""
-    var click: () -> Unit = {}
-    val children = mutableListOf<Node>()
-}
-private class TreeApplier(root: Node) : AbstractApplier<Node>(root) {
-    override fun insertTopDown(index: Int, instance: Node) { current.children.add(index, instance) }
-    override fun insertBottomUp(index: Int, instance: Node) {}
-    override fun remove(index: Int, count: Int) { repeat(count) { current.children.removeAt(index) } }
-    override fun move(from: Int, to: Int, count: Int) { current.children.move(from, to, count) }
-    override fun onClear() { root.children.clear() }
-}
-private val shared = mutableStateOf(0)
-@Composable
-private fun CounterTree() {
-    var count by remember { mutableStateOf(0) }
-    val value = "local=$count shared=${shared.value}"
-    ComposeNode<Node, TreeApplier>(
-        factory = { Node() },
-        update = {
-            set(value) { text = it }
-            set({ count += 1; shared.value += 1 }) { click = it }
-        }
-    )
-}
-
-private class RootEffects {
-    val launched = CompletableDeferred<Unit>()
-    val cancelled = CompletableDeferred<Unit>()
-    val frame = CompletableDeferred<Long>()
-    val scopeStarted = CompletableDeferred<Unit>()
-    val scopeCancelled = CompletableDeferred<Unit>()
-    var starts = 0
-    var disposals = 0
-    var scope: CoroutineScope? = null
-    var scopeJob: Job? = null
-}
-
-@Composable
-private fun LifecycleTree(label: String, effects: RootEffects) {
-    var count by remember { mutableStateOf(0) }
-    val scope = rememberCoroutineScope()
-    SideEffect { effects.scope = scope }
-    DisposableEffect(Unit) {
-        effects.starts += 1
-        onDispose { effects.disposals += 1 }
-    }
-    LaunchedEffect(Unit) {
-        effects.launched.complete(Unit)
-        try {
-            effects.frame.complete(withFrameNanos { it })
-            awaitCancellation()
-        } finally {
-            effects.cancelled.complete(Unit)
-        }
-    }
-    ComposeNode<Node, TreeApplier>(
-        factory = { Node() },
-        update = {
-            set("$label local=$count shared=${shared.value}") { text = it }
-            set({
-                count += 1
-                shared.value += 1
-                if (effects.scopeJob == null) effects.scopeJob = scope.launch {
-                    effects.scopeStarted.complete(Unit)
-                    try { awaitCancellation() } finally { effects.scopeCancelled.complete(Unit) }
-                }
-            }) { click = it }
-        }
-    )
-}
-
-object RuntimeState : OneModule {
-    fun failError(): Int = throw AssertionError("error boundary")
-
-    suspend fun checkLifecycle(retainRoot: Boolean, disposeRoot: Boolean): String = withTimeout(5_000) {
-        shared.value = 0
-        val a = Node()
-        val b = Node()
-        val leftEffects = RootEffects()
-        val rightEffects = RootEffects()
-        var label by mutableStateOf("original")
-        var frame = 0L
-        lateinit var clock: BroadcastFrameClock
-        clock = BroadcastFrameClock { launch { clock.sendFrame(++frame) } }
-        val recomposer = Recomposer(coroutineContext + clock)
-        val runner = launch(clock, CoroutineStart.UNDISPATCHED) { recomposer.runRecomposeAndApplyChanges() }
-        val left = Composition(TreeApplier(a), recomposer)
-        val right = Composition(TreeApplier(b), recomposer)
-        try {
-            left.setContent {
-                if (retainRoot) LifecycleTree(label, leftEffects)
-                else key(label) { LifecycleTree(label, leftEffects) }
-            }
-            right.setContent { LifecycleTree("right", rightEffects) }
-            leftEffects.launched.await()
-            rightEffects.launched.await()
-            val leftFrame = leftEffects.frame.await()
-            val rightFrame = rightEffects.frame.await()
-            check(leftFrame == rightFrame) { "roots received different frame times: $leftFrame/$rightFrame" }
-            recomposer.awaitIdle()
-            check(a.children.single().text == "original local=0 shared=0")
-            check(b.children.single().text == "right local=0 shared=0")
-            val original = a.children.single()
-            original.click()
-            b.children.single().click()
-            leftEffects.scopeStarted.await()
-            rightEffects.scopeStarted.await()
-            Snapshot.sendApplyNotifications()
-            recomposer.awaitIdle()
-            label = "updated"
-            Snapshot.sendApplyNotifications()
-            recomposer.awaitIdle()
-            check(a.children.single().text == "updated local=1 shared=2") {
-                "props update reset remembered state: ${a.children.single().text}"
-            }
-            check(a.children.single() === original) { "props update replaced the root node" }
-            check(b.children.single().text == "right local=1 shared=2") { "props update touched the other root" }
-            check(leftEffects.starts == 1 && leftEffects.disposals == 0) { "props update restarted effects" }
-            check(leftEffects.scope?.isActive == true && rightEffects.scope?.isActive == true)
-            if (disposeRoot) left.dispose()
-            check(leftEffects.disposals == 1) { "left disposal did not run DisposableEffect" }
-            leftEffects.cancelled.await()
-            leftEffects.scopeCancelled.await()
-            check(a.children.isEmpty()) { "left disposal retained nodes" }
-            check(leftEffects.scope?.isActive == false && leftEffects.scopeJob?.isCancelled == true)
-            check(rightEffects.disposals == 0 && !rightEffects.cancelled.isCompleted && !rightEffects.scopeCancelled.isCompleted) {
-                "left disposal cancelled the other root"
-            }
-            check(rightEffects.scope?.isActive == true && rightEffects.scopeJob?.isActive == true)
-            b.children.single().click()
-            Snapshot.sendApplyNotifications()
-            recomposer.awaitIdle()
-            check(b.children.single().text == "right local=2 shared=3") { "surviving root stopped recomposing" }
-            right.dispose()
-            rightEffects.cancelled.await()
-            rightEffects.scopeCancelled.await()
-            check(b.children.isEmpty() && rightEffects.disposals == 1)
-            check(rightEffects.scope?.isActive == false && rightEffects.scopeJob?.isCancelled == true)
-            JSONObject().put("passed", true).put("propsRetainState", true).put("propsRetainNode", true)
-                .put("effectsRetainIdentity", true).put("sharedFrameNanos", leftFrame)
-                .put("launchedEffectCancelled", true).put("disposableEffectDisposed", true)
-                .put("rememberedScopeCancelled", true).put("survivingRootRecomposes", true)
-                .put("uiProven", false).toString()
-        } finally {
-            left.dispose()
-            right.dispose()
-            recomposer.cancel()
-            runner.cancelAndJoin()
-        }
-    }
-
-    suspend fun checkState(startScheduler: Boolean): String = coroutineScope {
-        shared.value = 0
-        val a = Node()
-        val b = Node()
-        var frame = 0L
-        lateinit var clock: BroadcastFrameClock
-        clock = BroadcastFrameClock { launch { clock.sendFrame(++frame) } }
-        val recomposer = Recomposer(coroutineContext + clock)
-        val runner = launch(clock, if (startScheduler) CoroutineStart.UNDISPATCHED else CoroutineStart.LAZY) { recomposer.runRecomposeAndApplyChanges() }
-        val left = Composition(TreeApplier(a), recomposer)
-        val right = Composition(TreeApplier(b), recomposer)
-        try {
-            left.setContent { CounterTree() }
-            right.setContent { CounterTree() }
-            check(a.children.single().text == "local=0 shared=0") { "left initial: ${a.children.single().text}" }
-            check(b.children.single().text == "local=0 shared=0") { "right initial: ${b.children.single().text}" }
-            val original = a.children.single()
-            original.click()
-            Snapshot.sendApplyNotifications()
-            recomposer.awaitIdle()
-            check(a.children.single() === original) { "left node identity changed" }
-            check(a.children.single().text == "local=1 shared=1") { "left after click: ${a.children.single().text}" }
-            check(b.children.single().text == "local=0 shared=1") { "right shared update: ${b.children.single().text}" }
-            left.dispose()
-            check(a.children.isEmpty()) { "left dispose retained ${a.children.size} nodes" }
-            b.children.single().click()
-            Snapshot.sendApplyNotifications()
-            recomposer.awaitIdle()
-            check(b.children.single().text == "local=1 shared=2") { "right after click: ${b.children.single().text}" }
-            right.dispose()
-            check(b.children.isEmpty()) { "right dispose retained ${b.children.size} nodes" }
-            "{\"passed\":true,\"runtime\":\"androidx.compose.runtime:1.13.0-alpha02\",\"localState\":[0,1],\"sharedState\":[0,1,2],\"twoRoots\":true,\"retainedNode\":true,\"dispose\":true,\"uiProven\":false}"
-        } finally {
-            left.dispose()
-            right.dispose()
-            recomposer.cancel()
-            runner.cancelAndJoin()
-        }
-    }
-}

package/kotlin/fork/README.md

@@ -1,97 +0,0 @@
-# Peach's JetBrains web fork
-
-Peach runs Compose in a React Native tenant worker, with no `window`,
-`document`, `location`, or browser navigator language/platform fields. The official
-Compose UI 1.13.0-alpha01 and Skiko 0.152.0-alpha02 platform actuals assume
-browser globals that this native host does not publish. Peach carries patched
-builds until upstream supplies equivalent worker and native host hooks, and
-Android behavior for the approved web differences and static text shaping below.
-
-| module | file | native host binding |
-| --- | --- | --- |
-| Compose `foundation` | `Magnifier.web.kt`, `PlatformMagnifier.web.kt`, `TextFieldSelectionManager.web.kt` | Android magnifier modifier, semantics and selection animation with a scene-owned platform factory |
-| Compose `foundation` and `ui` | `RequestFocusOnClick.web.kt`, `Focusability.web.kt` | Android click and touch focus policy keeps sibling controls from taking a text field’s focus |
-| Compose `ui` | `Dialog.skiko.kt`, `PlatformContext.skiko.kt` | distinct Dialog window and navigation dispatcher isolate Back from the activity |
-| Compose `ui` and `foundation` | `Actuals.wasm.kt`, `UndoManager.web.kt` | clocks read `globalThis.performance.now()` |
-| Compose `ui` and `foundation` | `PlatformClipboard.web.kt`, `ClipboardUtils.wasm.kt` | worker-safe secure-context and clipboard reads |
-| Compose `ui` | `SystemTheme.kt` | `LocalSystemTheme` visible to the host, which provides the device's night mode |
-| Compose `ui-text` | `PlatformLocale.web.kt` | explicit `setPlatformLocaleProvider`; its default keeps upstream navigator behavior |
-| Compose `ui-skiko` | `SkiaBackedPaint.nonAndroid.kt` | initial Miter join agrees with the backing paint and Android |
-| Compose `ui-skiko` | `SkikoText.nonAndroid.kt`, `SkikoParagraphBuilder.nonAndroid.kt` | Android static advances and letter-spacing scale; Animated text retains fractional shaping |
-| Skia shaper | `SkShaper_harfbuzz.cpp` | measurement-font copy truncates static shaping size; the painted run font retains the requested size |
-| Skia raster | `SkFontHost_FreeType.cpp`, `SkFontHost_FreeType_common.cpp`, `SkSurface.cpp` | Android implicit autohinting policy and text gamma 1.4, contrast 0 |
-| Skia paragraph | `Run.cpp`, `TextLine.cpp`, `TextWrapper.cpp`, `DartTypes.h` | Android inter-glyph spacing, caret boundaries, edge trimming before line fits and integer center origins |
-| Compose `ui-skiko` | `SkikoParagraphIntrinsics.nonAndroid.kt`, `SkikoParagraph.nonAndroid.kt`, `SkikoParagraphBuilder.nonAndroid.kt` | Android letter-spacing intrinsic padding, centered line bounds, explicit center alignment and fitting BoringLayout line extents |
-| Skiko paragraph | `Alignment.kt` | transports the Android center ordinal without changing existing alignments |
-| Compose `material3` | `PlatformDateFormat.web.kt` | timestamp formatting uses UTC, as Android does |
-| Navigation `navigation-compose` | `DefaultNavTransitions.web.kt` | Android forward fades and predictive pop defaults |
-| Skiko | `OsArch.web.kt` | explicit `setHostOsProvider`; its default lazily retains upstream OS detection |
-| Skiko | `Actuals.web.kt` | nanosecond clock reads `globalThis.performance.now()` |
-| Skiko loader build | `OptimizeSkikoWasmTask.kt` | script directory reads `import.meta.url`, without `self.location` |
-| Skiko linker | `LinkSkikoTask.kt` | object paths sort before linking; library order retains its symbol resolution contract |
-
-The Compose host installs the locale provider once before any scene, from the
-same device locale it passes to `PlatformContext`, and installs `OS.Android`
-through Skiko’s host OS provider before any scene. Browser navigator fields
-stay absent in guest JS. Changes to device language after launch are outside
-this contract.
-
-`fork.json` pins repositories, commits, patch hashes, JDK and Android tools.
-Every changed upstream file carries a modification notice. `LICENSE` and
-`NOTICE` travel with the patches. `SKIA_LICENSE` records the modified Skia units’ BSD license. `build.sh` builds the changed KLIBs and Skiko
-runtime jar with the upstream Gradle builds on the Linux builder. The Skia shaping, paragraph and raster
-units are fetched at their pinned commit, patched, and compiled into Skiko; the linker
-uses them instead of the same units in the pinned Skia archive. All other Skia
-objects retain their upstream build. The linker sorts object paths, so filesystem
-enumeration does not change the Wasm binary. Static archives retain their declared
-order because that order controls symbol resolution. Sorting costs once per link,
-outside app runtime. FreeType headers match the pinned Skia DEPS revision;
-the FreeType binary remains the archive version. Raster changes add no allocation
-and retain the existing A8 preblend path. This adds no allocation beyond the existing
-measurement-font copy, and truncates once per shaped font, outside the glyph loop.
-Paragraph spacing adds constant arithmetic per glyph or cluster; line fits trim
-the same edge half-spaces as completed lines, without allocation. Android centered
-lines use the platform integer origin; other platforms retain fractional centering.
-Intrinsic measurement checks span letter spacing once and adds Android’s 0.5 px
-padding; line bounds use the platform floor and ceil. Fitting Android BoringLayout
-paragraphs expose the ceiled paragraph extent while preserving fractional glyph
-positions, including Animated text. Eligibility is scanned once per intrinsic
-construction. These corrections add no allocation. Skiko builds before Compose, whose `skiko-wasm-js` dependency resolves
-from this invocation’s Maven directory through `skiko-local.init.gradle`. The init
-script travels in the immutable build record with the patches.
-
-```sh
-delivery="scripts/tmp/kotlin-fork-$(date +%s)-$$"
-bun remote --delivery-dir "$delivery" bash packages/peachsim/kotlin/fork/build.sh
-bun packages/peachsim/kotlin/fork/publish.ts "$delivery/kotlin-fork"
-```
-
-The delivery includes `artifacts.sha256` and its exact fork record. Publication
-stores each binary at `peach-kotlin-fork/<binary-sha256>/<file>` and its record
-at `peach-kotlin-fork/<binary-sha256>/records/<record-sha256>/`. It refuses to
-replace existing bytes. A metadata change cannot overwrite a previous record
-when a binary is unchanged. `toolchain.json` pins these immutable binary URLs;
-all other Compose libraries remain official Maven artifacts. Everything stays
-lazy for Kotlin/Compose apps.
-
-The isolated worker probe cannot certify the native tenant's absent globals.
-`scripts/debug/peach-compose-mount/tenant-run.ts` boots the actual capture tenant
-with the imported `.kt` component, asserts those globals stay absent, and
-checks `Locale.current` and `LocalLocaleList` against an ar-EG device setting
-with an en-US browser.
-
-Delete the fork when official releases provide worker-safe clocks/clipboard,
-a location-independent loader and equivalent native locale/host OS provider hooks,
-plus UTC date formatting, Android navigation defaults, the correct initial paint join,
-Android magnifier lifecycle and Android static shaping size/advances,
-then rematch the Android pins in `plans/peach/kotlin-everywhere.md`. The prepared
-upstream issue names these hooks and the full guest regression vehicle.
-
-The static shaping correction is measured against the original `textwidth`
-fixture. The six original widths, twelve spacing assertions and the 162/164 px
-wrapping threshold pass their paired Android controls. The body Range probe
-retains its existing 0.00098 px difference. The original plain Month raster rows pass the strict 16/255 comparison in
-the actual Kotlin app; the old frame fails the retained raster check. Other
-pixel residuals remain open in the lane plan. The original Animated motion widths
-match Android, and the retained mixed-font/caret controls pass after the extent
-correction. These corrections do not certify full text parity.

package/kotlin/fork/build.sh

@@ -1,176 +0,0 @@
-#!/usr/bin/env bash
-#
-# builds Peach's patched JetBrains Kotlin/Wasm klibs on the linux builder and
-# delivers them to the caller's `.remote-out/kotlin-fork/`:
-#
-#   bun remote bash packages/peachsim/kotlin/fork/build.sh
-#
-# each upstream in fork.json is fetched at its pinned commit, gets its
-# committed patch, and builds with its own gradle build at the upstream's
-# kotlin compiler. only the modules the patches change are delivered. the
-# builder keeps the sources, the verified toolchain downloads, the sdk
-# platforms the compose build installs, and gradle's caches under
-# ~/builders/peach-kotlin-fork, so a rebuild is warm. the JDK and sdk tools are
-# unpacked fresh from their pinned archives every run, so a changed pin or an
-# altered install never survives into a build. bun remote already runs this under SCHED_IDLE with a
-# 16G memory bound; gradle and its in-process compiler stay inside it.
-
-set -euo pipefail
-
-FORK=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
-REPO_ROOT=$(cd "${FORK}/../../../.." && pwd)
-ROOT=$HOME/builders/peach-kotlin-fork
-DELIVER=${REPO_ROOT}/.remote-out/kotlin-fork
-
-mkdir -p "${ROOT}/downloads" "${ROOT}/src"
-exec 9>>"${ROOT}.lock"
-flock 9
-
-field() { node -p "const f = require('${FORK}/fork.json'); ${1}"; }
-
-fetch() {
-  local url=$1 sha256=$2 target=$3
-  if [[ -f "${target}" ]] && echo "${sha256}  ${target}" | sha256sum -c --status; then return; fi
-  curl -sfL --retry 3 -o "${target}.partial" "${url}"
-  if ! echo "${sha256}  ${target}.partial" | sha256sum -c --status; then
-    echo "${url} does not match its pinned sha256 ${sha256}" >&2
-    exit 2
-  fi
-  mv "${target}.partial" "${target}"
-}
-
-JDK=${ROOT}/jdk
-fetch "$(field 'f.toolchain.jdk.url')" "$(field 'f.toolchain.jdk.sha256')" "${ROOT}/downloads/jdk.tar.gz"
-rm -rf "${JDK}" && mkdir -p "${JDK}"
-tar -xzf "${ROOT}/downloads/jdk.tar.gz" -C "${JDK}" --strip-components=1
-
-SDK=${ROOT}/android-sdk
-fetch "$(field 'f.toolchain.androidCommandLineTools.url')" \
-  "$(field 'f.toolchain.androidCommandLineTools.sha256')" "${ROOT}/downloads/cmdline-tools.zip"
-rm -rf "${SDK}/cmdline-tools" && mkdir -p "${SDK}/cmdline-tools"
-unzip -q "${ROOT}/downloads/cmdline-tools.zip" -d "${SDK}/cmdline-tools"
-mv "${SDK}/cmdline-tools/cmdline-tools" "${SDK}/cmdline-tools/latest"
-# the compose build downloads the platforms it configures against, which needs
-# the sdk licenses accepted once
-JAVA_HOME=${JDK} "${SDK}/cmdline-tools/latest/bin/sdkmanager" --sdk_root="${SDK}" --licenses < <(yes) >/dev/null 2>&1
-
-export JAVA_HOME=${JDK} ANDROIDX_JDK21=${JDK} ANDROID_HOME=${SDK} ANDROID_SDK_ROOT=${SDK}
-export GRADLE_USER_HOME=${ROOT}/gradle-home
-M2=${ROOT}/m2
-
-# fetches one upstream at its pinned commit, discards anything a previous run
-# left in tracked files, and applies its patch after checking the patch hash.
-# sets SOURCE rather than printing it: a command substitution would drop
-# errexit and build on past a failed checkout or apply
-checkout() {
-  local index=$1
-  local name repository commit patch patch_sha256 dir
-  name=$(field "f.upstreams[${index}].name")
-  repository=$(field "f.upstreams[${index}].repository")
-  commit=$(field "f.upstreams[${index}].commit")
-  patch=${FORK}/$(field "f.upstreams[${index}].patch")
-  patch_sha256=$(field "f.upstreams[${index}].patchSha256")
-  dir=${ROOT}/src/${name}
-  if ! echo "${patch_sha256}  ${patch}" | sha256sum -c --status; then
-    echo "${patch} does not match fork.json patchSha256" >&2
-    exit 2
-  fi
-  if [[ ! -d "${dir}/.git" ]]; then
-    git init -q "${dir}"
-    git -C "${dir}" remote add origin "${repository}"
-  fi
-  if ! git -C "${dir}" cat-file -e "${commit}^{commit}" 2>/dev/null; then
-    git -C "${dir}" fetch -q --depth 1 origin "${commit}"
-  fi
-  git -C "${dir}" checkout -q -f --detach "${commit}"
-  git -C "${dir}" clean -fdq
-  if [[ $(git -C "${dir}" rev-parse HEAD) != "${commit}" ]]; then
-    echo "${name} is not at ${commit}" >&2
-    exit 2
-  fi
-  git -C "${dir}" apply "${patch}"
-  SOURCE=${dir}
-}
-
-gradle() {
-  ./gradlew --no-daemon --console=plain --max-workers=6 \
-    "-Dorg.gradle.jvmargs=-Xmx10g -XX:+UseParallelGC -Dfile.encoding=UTF-8" \
-    -Pkotlin.compiler.execution.strategy=in-process \
-    "-Dmaven.repo.local=${M2}" "$@"
-}
-
-rm -rf "${DELIVER}" "${M2}"
-mkdir -p "${DELIVER}"
-
-checkout 1
-SKIKO_SOURCE=${SOURCE}
-checkout 2
-# compile patched shaping and paragraph units in Skiko instead of their
-# upstream archive units. all other Skia objects remain pinned upstream.
-cmp "${SOURCE}/LICENSE" "${FORK}/SKIA_LICENSE"
-cp "${SOURCE}/modules/skshaper/src/SkShaper_harfbuzz.cpp"   "${SKIKO_SOURCE}/skiko/src/nativeJsMain/cpp/AndroidShaper.cpp"
-# internal paragraph headers come from the same pinned source as the archive.
-rsync -a --include='*/' --include='*.h' --exclude='*' "${SOURCE}/include/" "${SKIKO_SOURCE}/skiko/src/nativeJsMain/cpp/include/"
-rsync -a --include='*/' --include='*.h' --exclude='*' "${SOURCE}/modules/" "${SKIKO_SOURCE}/skiko/src/nativeJsMain/cpp/modules/"
-rsync -a --include='*/' --include='*.h' --exclude='*' "${SOURCE}/src/" "${SKIKO_SOURCE}/skiko/src/nativeJsMain/cpp/src/"
-cp "${SOURCE}/modules/skparagraph/src/Run.cpp" "${SKIKO_SOURCE}/skiko/src/nativeJsMain/cpp/AndroidParagraphRun.cpp"
-cp "${SOURCE}/modules/skparagraph/src/TextLine.cpp" "${SKIKO_SOURCE}/skiko/src/nativeJsMain/cpp/AndroidParagraphTextLine.cpp"
-cp "${SOURCE}/modules/skparagraph/src/TextWrapper.cpp" "${SKIKO_SOURCE}/skiko/src/nativeJsMain/cpp/AndroidParagraphTextWrapper.cpp"
-# the raster units use the same freetype headers as the pinned skia archive.
-FREETYPE_SOURCE=${ROOT}/src/freetype
-FREETYPE_REPOSITORY=$(field 'f.toolchain.freetypeHeaders.repository')
-FREETYPE_COMMIT=$(field 'f.toolchain.freetypeHeaders.commit')
-if ! grep -Fq "${FREETYPE_REPOSITORY}@${FREETYPE_COMMIT}" "${SOURCE}/DEPS"; then
-  echo "freetype headers differ from the pinned skia dependency" >&2
-  exit 2
-fi
-if [[ ! -d "${FREETYPE_SOURCE}/.git" ]]; then
-  git init -q "${FREETYPE_SOURCE}"
-  git -C "${FREETYPE_SOURCE}" remote add origin "${FREETYPE_REPOSITORY}"
-fi
-if ! git -C "${FREETYPE_SOURCE}" cat-file -e "${FREETYPE_COMMIT}^{commit}" 2>/dev/null; then
-  git -C "${FREETYPE_SOURCE}" fetch -q --depth 1 origin "${FREETYPE_COMMIT}"
-fi
-git -C "${FREETYPE_SOURCE}" checkout -q -f --detach "${FREETYPE_COMMIT}"
-if [[ $(git -C "${FREETYPE_SOURCE}" rev-parse HEAD) != "${FREETYPE_COMMIT}" ]]; then
-  echo "freetype headers are not at ${FREETYPE_COMMIT}" >&2
-  exit 2
-fi
-rsync -a --delete "${FREETYPE_SOURCE}/include/" "${SKIKO_SOURCE}/skiko/src/nativeJsMain/cpp/freetype/"
-cp "${SOURCE}/src/ports/SkFontHost_FreeType.cpp" "${SKIKO_SOURCE}/skiko/src/nativeJsMain/cpp/AndroidFreeType.cpp"
-cp "${SOURCE}/src/ports/SkFontHost_FreeType_common.cpp" "${SKIKO_SOURCE}/skiko/src/nativeJsMain/cpp/AndroidFreeTypeCommon.cpp"
-cp "${SOURCE}/src/image/SkSurface.cpp" "${SKIKO_SOURCE}/skiko/src/nativeJsMain/cpp/AndroidSurface.cpp"
-(
-  cd "${SKIKO_SOURCE}/skiko"
-  gradle -Pdeploy.version=0.152.0-alpha02 -Pdeploy.release=true \
-    -Pskiko.wasm.enabled=true -Pskiko.awt.enabled=false \
-    :publishWasmJsPublicationToMavenLocal :skikoWasmJar
-  cp build/libs/skiko-wasm-0.152.0-alpha02.jar "${DELIVER}/"
-)
-
-checkout 0
-(
-  cd "${SOURCE}"
-  gradle -I "${FORK}/skiko-local.init.gradle" -Pcompose.platforms=web -Pjetbrains.publication.version.COMPOSE=1.13.0-alpha01 \
-    -Pjetbrains.publication.version.COMPOSE_MATERIAL3=1.13.0-alpha01 \
-    -Pjetbrains.publication.version.NAVIGATION=2.10.0-beta01 \
-    :compose:ui:ui:publishWasmJsPublicationToMavenLocal \
-    :compose:foundation:foundation:publishWasmJsPublicationToMavenLocal \
-    :compose:ui:ui-text:publishWasmJsPublicationToMavenLocal \
-    :compose:ui:ui-skiko:publishWasmJsPublicationToMavenLocal \
-    :compose:material3:material3:publishWasmJsPublicationToMavenLocal \
-    :navigation:navigation-compose:publishWasmJsPublicationToMavenLocal
-)
-
-cp "${M2}/org/jetbrains/compose/ui/ui-wasm-js/1.13.0-alpha01/ui-wasm-js-1.13.0-alpha01.klib" \
-  "${M2}/org/jetbrains/compose/foundation/foundation-wasm-js/1.13.0-alpha01/foundation-wasm-js-1.13.0-alpha01.klib" \
-  "${M2}/org/jetbrains/compose/ui/ui-text-wasm-js/1.13.0-alpha01/ui-text-wasm-js-1.13.0-alpha01.klib" \
-  "${M2}/org/jetbrains/compose/ui/ui-skiko-wasm-js/1.13.0-alpha01/ui-skiko-wasm-js-1.13.0-alpha01.klib" \
-  "${M2}/org/jetbrains/compose/material3/material3-wasm-js/1.13.0-alpha01/material3-wasm-js-1.13.0-alpha01.klib" \
-  "${M2}/org/jetbrains/androidx/navigation/navigation-compose-wasm-js/2.10.0-beta01/navigation-compose-wasm-js-2.10.0-beta01.klib" \
-  "${M2}/org/jetbrains/skiko/skiko-wasm-js/0.152.0-alpha02/skiko-wasm-js-0.152.0-alpha02.klib" \
-  "${DELIVER}/"
-# the record travels with the klibs it describes, so publishing attaches what
-# this build used, not whatever the checkout holds later
-cp "${FORK}/fork.json" "${FORK}/LICENSE" "${FORK}/NOTICE" "${FORK}/SKIA_LICENSE" "${FORK}"/*.patch "${FORK}/skiko-local.init.gradle" "${DELIVER}/"
-(cd "${DELIVER}" && sha256sum -- *.klib *.jar > artifacts.sha256 && cat artifacts.sha256)