peachsim 0.1.854 → 0.1.871

package/kotlin/fork/skia-android-shaping.patch

@@ -17,5 +17,128 @@ diff --git a/modules/skshaper/src/SkShaper_harfbuzz.cpp b/modules/skshaper/src/S
 -    int scale = skhb_position(font.getSize());
 +    int scale = skhb_position(measurementFont->getSize());
      hb_font_set_scale(skFont.get(), scale, scale);
- 
+
      return skFont;
+diff --git a/modules/skparagraph/src/Run.cpp b/modules/skparagraph/src/Run.cpp
+--- a/modules/skparagraph/src/Run.cpp
++++ b/modules/skparagraph/src/Run.cpp
+@@ -177,9 +177,13 @@
+ SkScalar Run::addLetterSpacesEvenly(SkScalar space) {
+     SkScalar shift = 0;
+     for (size_t i = 0; i < this->size(); ++i) {
+-        fPositions[i].fX += shift;
++        // modified for the Android host: boundaries bisect inter-glyph spaces.
++        const auto halfSpace = i == 0 ? 0 : space / 2;
++        fPositions[i].fX += shift - halfSpace;
++        fOffsets[i].fX += halfSpace;
+         shift += space;
+     }
++    if (this->size() > 0) shift -= space;
+     fPositions[this->size()].fX += shift;
+     fAdvance.fX += shift;
+     return shift;
+@@ -190,8 +194,14 @@
+     SkScalar shift = 0;
+     for (size_t i = cluster->startPos(); i < cluster->endPos(); ++i) {
+         fPositions[i].fX += shift;
++        // modified for the Android host: paint retains the inward half-space.
++        const auto halfSpace = cluster->textRange().start == 0 && i == 0 ? 0 : space / 2;
++        fOffsets[i].fX += halfSpace;
+         shift += space;
+     }
++    // trim paragraph edges; font runs inside the paragraph keep their spacing.
++    if (cluster->textRange().start == 0) shift -= space / 2;
++    if (cluster->textRange().end == fOwner->text().size()) shift -= space / 2;
+     if (this->size() == cluster->endPos()) {
+         // To make calculations easier
+         fPositions[cluster->endPos()].fX += shift;
+diff --git a/modules/skparagraph/src/TextLine.cpp b/modules/skparagraph/src/TextLine.cpp
+--- a/modules/skparagraph/src/TextLine.cpp
++++ b/modules/skparagraph/src/TextLine.cpp
+@@ -177,13 +177,16 @@
+         }
+     }
+
+-    // TODO: This is the fix for flutter. Must be removed...
+-    for (auto cluster = &start; cluster <= &end; ++cluster) {
+-        if (!cluster->run().isPlaceholder() && !cluster->run().isCursiveScript()) {
+-            fShift += cluster->getHalfLetterSpacing();
+-            break;
+-        }
+-    }
++    // modified for the Android host: trim half-spaces at wrapped line edges.
++    if (fClusterRange.start < fClusterRange.end) {
++        const auto& first = fOwner->cluster(fClusterRange.start);
++        const auto& last = fOwner->cluster(fClusterRange.end - 1);
++        const auto leading = first.textRange().start == 0 ? 0 : first.getHalfLetterSpacing();
++        const auto trailing = last.textRange().end == fOwner->text().size() ? 0 : last.getHalfLetterSpacing();
++        fAdvance.fX -= leading + trailing;
++        fWidthWithSpaces -= leading;
++    }
++
+ }
+
+ void TextLine::paint(ParagraphPainter* painter, SkScalar x, SkScalar y) {
+@@ -881,6 +884,10 @@
+     result.size = (end->isHardBreak() ? end->startPos() : end->endPos()) - start->startPos();
+     auto textStartInRun = run->positionX(start->startPos());
+     auto textStartInLine = runOffsetInLine + textOffsetInRunInLine;
++    if (fClusterRange.start < fClusterRange.end) {
++        const auto& first = fOwner->cluster(fClusterRange.start);
++        if (first.textRange().start != 0) textStartInLine -= first.getHalfLetterSpacing();
++    }
+     if (!run->leftToRight()) {
+         std::swap(start, end);
+     }
+@@ -928,6 +935,7 @@
+     }
+
+     result.clip.offset(textStartInLine, 0);
++    if (originalTextRange.start == fTextExcludingSpaces.start) result.clip.fLeft = std::max(result.clip.fLeft, 0.0f);
+     //SkDebugf("@%f[%f:%f)\n", textStartInLine, result.clip.fLeft, result.clip.fRight);
+
+     if (compareRound(result.clip.fRight, fAdvance.fX, fOwner->getApplyRoundingHack()) > 0 && !includeGhostSpaces) {
+--- a/modules/skparagraph/src/TextWrapper.cpp
++++ b/modules/skparagraph/src/TextWrapper.cpp
+@@ -58,12 +58,19 @@
+     fClip.startFrom(fEndLine.startCluster(), fEndLine.startPos());
+ 
+     LineBreakerWithLittleRounding breaker(maxWidth, applyRoundingHack);
++    // modified for the Android host: fit the same trimmed edges as TextLine.
++    const auto lineWidth = [endOfClusters](SkScalar width, const Cluster* first, const Cluster* last) {
++        if (first->textRange().start != 0) width -= first->getHalfLetterSpacing();
++        if (last + 1 != endOfClusters) width -= last->getHalfLetterSpacing();
++        return width;
++    };
+     Cluster* nextNonBreakingSpace = nullptr;
+     for (auto cluster = fEndLine.endCluster(); cluster < endOfClusters; ++cluster) {
+         if (cluster->isHardBreak()) {
+         } else if (
+                 // TODO: Trying to deal with flutter rounding problem. Must be removed...
+-                SkScalar width = fWords.width() + fClusters.width() + cluster->width();
++                SkScalar width = lineWidth(fWords.width() + fClusters.width() + cluster->width(),
++                                           fEndLine.startCluster(), cluster);
+                 breaker.breakLine(width)) {
+             if (cluster->isWhitespaceBreak()) {
+                 // It's the end of the word
+@@ -93,6 +100,7 @@
+             // Walk further to see if there is a too long word, cluster or glyph
+             SkScalar nextWordLength = fClusters.width();
+             SkScalar nextShortWordLength = nextWordLength;
++            auto wordEnd = cluster;
+             for (auto further = cluster; further != endOfClusters; ++further) {
+                 if (further->isSoftBreak() || further->isHardBreak() || further->isWhitespaceBreak()) {
+                     break;
+@@ -113,8 +121,10 @@
+                     nextWordLength = std::max(nextWordLength, further->width());
+                 } else {
+                     nextWordLength += further->width();
+-                }
+-            }
++                    wordEnd = further;
++                }
++            }
++            nextWordLength = lineWidth(nextWordLength, fClusters.startCluster(), wordEnd);
+             if (nextWordLength > maxWidth) {
+                 if (nextNonBreakingSpace != nullptr) {
+                     // We only get here if the non-breaking space improves our situation

package/kotlin/toolchain.json

@@ -325,9 +325,9 @@
     "skiko": "0.152.0-alpha02"
   },
   "composeRuntime": {
-    "name": "skiko-wasm-0.152.0-alpha02-peach-637f2f8ae1fa.jar",
-    "url": "https://r2.rnxsim.com/peach-kotlin-fork/637f2f8ae1fa804fd5ef85259d7b45877b07dd98e439eb4f3cc9560db3eba651/skiko-wasm-0.152.0-alpha02.jar",
-    "sha256": "637f2f8ae1fa804fd5ef85259d7b45877b07dd98e439eb4f3cc9560db3eba651"
+    "name": "skiko-wasm-0.152.0-alpha02-peach-8b1b394f5d3b.jar",
+    "url": "https://r2.rnxsim.com/peach-kotlin-fork/8b1b394f5d3b3ac096c966de34855cf90625b8c0322f39d18cdfc619f21816e8/skiko-wasm-0.152.0-alpha02.jar",
+    "sha256": "8b1b394f5d3b3ac096c966de34855cf90625b8c0322f39d18cdfc619f21816e8"
   },
   "composeJsLibraries": [
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peachsim",
-  "version": "0.1.854",
+  "version": "0.1.871",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for peach.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",

package/skills/contrast/SKILL.md

@@ -131,8 +131,8 @@ what this means:
 - `peach do tap login` then `peach find "Welcome"` Just Works™.
 - you only need `peach do settle <seconds>` or `peach wait idle
   --max-ms <N>` when the CLI explicitly prints
-  `⚠ auto-wait timed out after Nms — next command may see mid-animation
-  state`, or when the transition you care about lasts longer than ~400 ms
+  `⚠ auto-wait timed out after Nms (<what still moved>) — next command may
+  see mid-animation state`, or when the transition you care about lasts longer than ~400 ms
   (full stack navigation, crossfades, video load).
 - opt-out: `--no-wait` on a single command, `PEACH_NO_AUTO_WAIT=1`
   for a whole lane.

package/skills/peach-debug/SKILL.md

@@ -126,8 +126,8 @@ toast · 1 screen push`, run `peach what-happened` to see the detail.
 every CLI command already participates in a two-phase settle. you only
 need a manual wait when:
 
-1. the CLI explicitly printed `⚠ auto-wait timed out after Nms — next
-   command may see mid-animation state` *and* your next read depends on
+1. the CLI explicitly printed `⚠ auto-wait timed out after Nms (<what
+   still moved>) — next command may see mid-animation state` *and* your next read depends on
    the animation finishing.
 2. the transition is longer than ~400 ms (full stack navigation,
    crossfades, video first-frame, network-backed render).

package/src/swift-host.ts

@@ -766,6 +766,7 @@ function packageSources(packagePath: string): Record<string, string> {
 
 interface SwiftPackageSnapshot {
   files: Record<string, string>
+  entry: string
   resourcePaths: string[]
   resources: SwiftResourceTable
   bundleFiles: SwiftBundlePack
@@ -773,11 +774,15 @@ interface SwiftPackageSnapshot {
   glue?: string
 }
 
-function packageSnapshot(project: SwiftProject): SwiftPackageSnapshot {
+function packageSnapshot(project: SwiftProject, entry: string): SwiftPackageSnapshot {
   const files = packageSources(project.packagePath)
+  const layout = xcodeLayout(project.packagePath)
   const native = nativeSourceDescriptor(project.packagePath)
   return {
     files,
+    entry: layout
+      ? xcodeInputKey(layout, path.resolve(project.packagePath, entry), entry)
+      : entry,
     resourcePaths: swiftImplicitResourcePaths(
       resourceCandidateFiles(project.packagePath).map((file) =>
         path.relative(project.packagePath, file).split(path.sep).join(path.posix.sep),
@@ -798,28 +803,24 @@ function packageSnapshot(project: SwiftProject): SwiftPackageSnapshot {
   }
 }
 
-function snapshotCompileInput(
-  snapshot: SwiftPackageSnapshot,
-  entry: string,
-): SwiftCompileInput {
+function snapshotCompileInput(snapshot: SwiftPackageSnapshot): SwiftCompileInput {
   const input: SwiftCompileInput = {
     files: snapshot.files,
     resourcePaths: snapshot.resourcePaths,
     resources: snapshot.bundleFiles.files,
     images: snapshot.resources.images,
-    entry,
+    entry: snapshot.entry,
     oneModule: true,
   }
   return snapshot.glue ? withNativeSourceGlue(input, snapshot.glue) : input
 }
 
 export function compileInput(packagePath: string, entry: string): SwiftCompileInput {
-  return snapshotCompileInput(packageSnapshot(projectFor(packagePath)), entry)
+  return snapshotCompileInput(packageSnapshot(projectFor(packagePath), entry))
 }
 
 async function compile(
   packagePath: string,
-  entry: string,
   stamp: string,
   moduleRootOverride: string | undefined,
   hosted: SwiftHostedCompileOptions | undefined,
@@ -838,7 +839,7 @@ async function compile(
   }
   if (hosted)
     return {
-      ...(await compileRemote(packagePath, entry, snapshot, hosted)),
+      ...(await compileRemote(packagePath, snapshot, hosted)),
       stamp,
       package: content,
     }
@@ -852,12 +853,12 @@ async function compile(
     (await swiftDistributionRoot())
   if (!moduleRoot)
     return {
-      ...(await compileRemote(packagePath, entry, snapshot)),
+      ...(await compileRemote(packagePath, snapshot)),
       stamp,
       package: content,
     }
   const toolchain = swiftModuleToolchain(moduleRoot)
-  const input = snapshotCompileInput(snapshot, entry)
+  const input = snapshotCompileInput(snapshot)
   const targets = compileTargets(input).map((target) => target.name)
   const missing = missingSwiftModules(
     input.files,
@@ -1049,7 +1050,6 @@ async function missingModulesMessage(
 // immutable local asset addresses.
 async function compileRemote(
   packagePath: string,
-  entry: string,
   snapshot: SwiftPackageSnapshot,
   hosted?: SwiftHostedCompileOptions,
 ): Promise<Omit<SwiftArtifact, 'stamp' | 'package'>> {
@@ -1092,7 +1092,7 @@ async function compileRemote(
       resourcePaths: snapshot.resourcePaths,
       resources: snapshot.bundleFiles.files,
       images: snapshot.resources.images,
-      entry,
+      entry: snapshot.entry,
       packageId: descriptor?.packageId ?? swiftPackageId(packagePath),
     },
     origin,
@@ -1154,13 +1154,12 @@ export function artifactFor(
     const again = () => artifactFor(project, entry, moduleRoot)
     return running.promise.then(again, again)
   }
-  const snapshot = packageSnapshot(project)
+  const snapshot = packageSnapshot(project, entry)
   if (sourceStamp(project.packagePath, moduleRoot, Boolean(project.hosted)) !== stamp) {
     return artifactFor(project, entry, moduleRoot)
   }
   const promise = compile(
     project.packagePath,
-    entry,
     stamp,
     moduleRoot,
     project.hosted,