fix(ci): harden TypeScript SDK native publish

.github/workflows/release-typescript-sdk.yml

@@ -103,6 +103,7 @@ jobs:
     needs: verify
     runs-on: ${{ matrix.runner }}
     timeout-minutes: 60
+    continue-on-error: true
     strategy:
       fail-fast: false
       matrix:
@@ -131,6 +132,8 @@ jobs:
 
       - name: Setup Rust CI toolchain and tools
         uses: ./.github/actions/rust-ci-setup
+        with:
+          cargo-tools: cargo-make,cargo-nextest
 
       - name: Setup pnpm
         uses: pnpm/action-setup@v4
@@ -154,7 +157,7 @@ jobs:
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
         shell: bash
-        run: pnpm publish --access public --no-git-checks
+        run: node ../../scripts/publish-package.mjs
 
       - name: Pack native runtime package
         if: needs.verify.outputs.publish_release != 'true'
@@ -239,7 +242,7 @@ jobs:
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
         shell: bash
-        run: pnpm publish --access public --no-git-checks
+        run: node scripts/publish-package.mjs
 
       - name: Pack TypeScript SDK
         if: needs.verify.outputs.publish_release != 'true'

Cargo.toml

@@ -13,6 +13,8 @@ exclude = ["crates/sof-solana-gossip"]
 [patch.crates-io]
 sof-solana-gossip = { path = "crates/sof-solana-gossip" }
 helius-laserstream = { path = "vendor/helius-laserstream" }
+laserstream-core-proto = { path = "vendor/laserstream-core-proto" }
+yellowstone-grpc-client = { path = "vendor/yellowstone-grpc-client" }
 
 [workspace.package]
 edition = "2024"

crates/sof-observer/src/ingest/config.rs

@@ -70,18 +70,21 @@ pub(super) fn read_udp_idle_wait_ms() -> u64 {
         .unwrap_or(100)
 }
 
+#[cfg(target_os = "linux")]
 pub(super) fn read_udp_busy_poll_us() -> Option<u32> {
     read_env_var("SOF_UDP_BUSY_POLL_US")
         .and_then(|value| value.parse::<u32>().ok())
         .filter(|value| *value > 0)
 }
 
+#[cfg(target_os = "linux")]
 pub(super) fn read_udp_busy_poll_budget() -> Option<u32> {
     read_env_var("SOF_UDP_BUSY_POLL_BUDGET")
         .and_then(|value| value.parse::<u32>().ok())
         .filter(|value| *value > 0)
 }
 
+#[cfg(target_os = "linux")]
 pub(super) fn read_udp_prefer_busy_poll() -> bool {
     read_bool_env("SOF_UDP_PREFER_BUSY_POLL", false)
 }
@@ -90,6 +93,7 @@ pub(super) fn read_udp_drop_on_channel_full() -> bool {
     read_bool_env("SOF_UDP_DROP_ON_CHANNEL_FULL", true)
 }
 
+#[cfg(target_os = "linux")]
 fn read_udp_track_rxq_ovfl() -> bool {
     read_bool_env("SOF_UDP_TRACK_RXQ_OVFL", false)
 }

crates/sof-observer/src/ingest/receiver/core.rs

@@ -142,6 +142,7 @@ impl RawPacketBatch {
         storage.packets.reserve(additional);
     }
 
+    #[cfg(target_os = "linux")]
     pub(super) fn ensure_receive_slots(&mut self, additional: usize) -> usize {
         let Some(storage) = self.storage.as_mut() else {
             return 0;
@@ -156,13 +157,15 @@ impl RawPacketBatch {
         start_index
     }
 
+    #[cfg(target_os = "linux")]
     pub(super) fn receive_buffer_mut(
         &mut self,
         buffer_index: usize,
     ) -> Option<&mut [u8; UDP_PACKET_BUFFER_BYTES]> {
         self.storage.as_mut()?.buffers.get_mut(buffer_index)
     }
 
+    #[cfg(target_os = "linux")]
     pub(super) fn push_received_metadata(
         &mut self,
         source: SocketAddr,
@@ -366,6 +369,7 @@ impl ReceiverTelemetry {
             .store(current_unix_ms(), Ordering::Relaxed);
     }
 
+    #[cfg(target_os = "linux")]
     fn record_packets(&self, packet_count: usize) {
         self.packets.fetch_add(
             u64::try_from(packet_count).unwrap_or(u64::MAX),

crates/sof-observer/src/runtime.rs

@@ -8,7 +8,7 @@ use std::{
     path::PathBuf,
     pin::Pin,
     sync::Arc,
-    thread::{self, available_parallelism},
+    thread::available_parallelism,
     time::{Duration, Instant},
 };
 
@@ -3449,7 +3449,7 @@ async fn wait_for_termination_signal() {
     #[cfg(unix)]
     {
         let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel();
-        thread::spawn(move || {
+        std::thread::spawn(move || {
             let mut signals = match signal_hook::iterator::Signals::new([
                 signal_hook::consts::signal::SIGTERM,
                 signal_hook::consts::signal::SIGINT,
@@ -3822,7 +3822,6 @@ mod tests {
             Arc, Mutex,
             atomic::{AtomicUsize, Ordering},
         },
-        thread,
         time::Instant,
     };
 
@@ -5326,7 +5325,7 @@ mod tests {
             if counter.load(Ordering::Relaxed) >= expected {
                 return true;
             }
-            thread::sleep(Duration::from_millis(10));
+            std::thread::sleep(Duration::from_millis(10));
         }
         counter.load(Ordering::Relaxed) >= expected
     }

pnpm-workspace.yaml

@@ -1,3 +1,6 @@
 packages:
   - sdks/typescript
   - sdks/typescript/native/*
+
+onlyBuiltDependencies:
+  - "@biomejs/biome"

sdks/typescript/scripts/build-native-host.mjs

@@ -1,13 +1,72 @@
 import { spawnSync } from "node:child_process";
 import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
-import { basename, join } from "node:path";
+import { basename, delimiter, join } from "node:path";
 
 const scriptDirectory = import.meta.dirname;
 const sdkPackageDirectory = join(scriptDirectory, "..");
 const workspaceDirectory = join(sdkPackageDirectory, "..", "..");
+const cargoTargetRoot = process.env.CARGO_TARGET_DIR ?? join(workspaceDirectory, "target");
+const overriddenPlatform = process.env.SOF_TS_NATIVE_PLATFORM;
+const overriddenArch = process.env.SOF_TS_NATIVE_ARCH;
+const overriddenTarget = process.env.SOF_TS_NATIVE_TARGET;
+const cargoSubcommand = process.env.SOF_TS_NATIVE_CARGO_SUBCOMMAND;
+const crossBuildCargoSubcommand = "zigbuild";
 
-function runtimeHostBinaryName() {
-  return process.platform === "win32" ? "sof_ts_runtime_host.exe" : "sof_ts_runtime_host";
+function packagePlatformFromDirectory(packageDirectory) {
+  const name = basename(packageDirectory);
+  const separator = name.indexOf("-");
+  if (separator === -1) {
+    return;
+  }
+
+  return {
+    arch: name.slice(separator + 1),
+    platform: name.slice(0, separator),
+  };
+}
+
+function buildPlatform(packageDirectory) {
+  return (
+    overriddenPlatform ??
+    packagePlatformFromDirectory(packageDirectory)?.platform ??
+    process.platform
+  );
+}
+
+function buildArch(packageDirectory) {
+  return overriddenArch ?? packagePlatformFromDirectory(packageDirectory)?.arch ?? process.arch;
+}
+
+function runtimeHostBinaryName(platform) {
+  return platform === "win32" ? "sof_ts_runtime_host.exe" : "sof_ts_runtime_host";
+}
+
+function defaultCargoTarget(platform, arch) {
+  if (platform === process.platform && arch === process.arch) {
+    return;
+  }
+
+  if (platform === "darwin" && arch === "x64") {
+    return "x86_64-apple-darwin";
+  }
+  if (platform === "darwin" && arch === "arm64") {
+    return "aarch64-apple-darwin";
+  }
+  if (platform === "win32" && arch === "x64") {
+    return "x86_64-pc-windows-gnu";
+  }
+  if (platform === "win32" && arch === "arm64") {
+    return "aarch64-pc-windows-gnullvm";
+  }
+  if (platform === "linux" && arch === "arm64") {
+    return "aarch64-unknown-linux-gnu";
+  }
+}
+
+function defaultCargoSubcommand(target) {
+  if (target !== undefined) {
+    return crossBuildCargoSubcommand;
+  }
 }
 
 function nativePackageDirectory() {
@@ -29,7 +88,7 @@ function packageMetadata(packageDirectory) {
   const packageJsonPath = join(packageDirectory, "package.json");
   if (!existsSync(packageJsonPath)) {
     throw new Error(
-      `native package metadata was not found at ${packageJsonPath}; expected a package for ${process.platform}-${process.arch}`,
+      `native package metadata was not found at ${packageJsonPath}; expected a package for ${buildPlatform()}-${buildArch()}`,
     );
   }
 
@@ -38,40 +97,62 @@ function packageMetadata(packageDirectory) {
 
 const packageDirectory = nativePackageDirectory();
 const packageJson = packageMetadata(packageDirectory);
+const platform = buildPlatform(packageDirectory);
+const arch = buildArch(packageDirectory);
+const target = overriddenTarget ?? defaultCargoTarget(platform, arch);
+const subcommand = cargoSubcommand ?? defaultCargoSubcommand(target);
 const outputDirectory = join(packageDirectory, "vendor");
-const outputPath = join(outputDirectory, runtimeHostBinaryName());
-const sourcePath = join(workspaceDirectory, "target", "release", runtimeHostBinaryName());
+const binaryName = runtimeHostBinaryName(platform);
+const targetDirectory = target === undefined ? "release" : join(target, "release");
+const outputPath = join(outputDirectory, binaryName);
+const sourcePath = join(cargoTargetRoot, targetDirectory, binaryName);
 const features = ["provider-websocket", "provider-grpc", "gossip-bootstrap"];
 
-if (process.platform === "linux") {
+if (platform === "linux") {
   features.push("kernel-bypass");
 }
 
 const packagePlatform = basename(packageDirectory);
-if (packagePlatform !== `${process.platform}-${process.arch}`) {
+const currentPlatformKey = `${platform}-${arch}`;
+if (packagePlatform !== currentPlatformKey) {
   throw new Error(
-    `native package ${packageJson.name ?? packagePlatform} does not match the current platform ${process.platform}-${process.arch}`,
+    `native package ${packageJson.name ?? packagePlatform} does not match the selected platform ${currentPlatformKey}`,
   );
 }
 
-const cargo = spawnSync(
-  "cargo",
-  [
-    "build",
-    "--release",
-    "-p",
-    "sof",
-    "--features",
-    features.join(","),
-    "--bin",
-    "sof_ts_runtime_host",
-  ],
-  {
-    cwd: workspaceDirectory,
-    stdio: "inherit",
-  },
+const cargoArgs = [];
+if (subcommand !== undefined && subcommand.length > 0) {
+  cargoArgs.push(subcommand);
+} else {
+  cargoArgs.push("build");
+}
+if (target !== undefined) {
+  cargoArgs.push("--target", target);
+}
+cargoArgs.push(
+  "--release",
+  "-p",
+  "sof",
+  "--features",
+  features.join(","),
+  "--bin",
+  "sof_ts_runtime_host",
 );
 
+const cargoEnv = { ...process.env };
+cargoEnv.PATH = [join(sdkPackageDirectory, "node_modules", ".bin"), cargoEnv.PATH]
+  .filter((value) => value !== undefined && value.length > 0)
+  .join(delimiter);
+if (platform === "darwin") {
+  cargoEnv.CARGO_PROFILE_RELEASE_LTO = "off";
+}
+
+const cargo = spawnSync("cargo", cargoArgs, {
+  cwd: workspaceDirectory,
+  env: cargoEnv,
+  stdio: "inherit",
+});
+
 if (cargo.error !== undefined) {
   throw new Error(`failed to run cargo: ${cargo.error.message}`);
 }
@@ -87,6 +168,6 @@ if (!existsSync(sourcePath)) {
 
 mkdirSync(outputDirectory, { recursive: true });
 copyFileSync(sourcePath, outputPath);
-if (process.platform !== "win32") {
+if (platform !== "win32") {
   chmodSync(outputPath, 0o755);
 }