# Takanawa

Takanawa is a Rust range-download library designed to ship as a C ABI dynamic
library on Windows, macOS, Linux, Android, and iOS. The current implementation stores
download state in a `.part` file with dual metadata slots so interrupted
downloads can resume automatically.

## Workspace

- `takanawa-core`: chunk planning, `.part` metadata, file recovery, SHA-1/SHA-256/SHA-512/MD5/CRC32 hash checks.
- `takanawa-http`: Tokio/reqwest HTTP range download engine.
- `takanawa-ffi`: C ABI wrapper built as `cdylib` and `staticlib`.
- `takanawa-cli`: small dogfood CLI.
- `packages/takanawa-csharp`: C# SDK published as `YetAnotherAI.Takanawa`
  on NuGet for desktop .NET, Unity, Godot, Android, and iOS consumers.
- `android/takanawa-android`: Kotlin-first Android SDK published as an AAR.
- `packages/takanawa-js-core`: Private shared TypeScript facade bundled into
  npm target packages.
- `packages/takanawa-node`: Node.js and Electron bindings published to npm.
- `packages/takanawa-capacitor`: Capacitor plugin published to npm. The plugin
  ships Android and iOS bridge source and depends on the Android AAR and SwiftPM
  package at the same Takanawa version.
- `packages/takanawa-tauri`: Tauri v2 plugin published as the `takanawa-tauri`
  npm package and the `tauri-plugin-takanawa` Rust crate. The frontend package
  uses the shared TypeScript API while the Rust plugin compiles into the host
  Tauri app.

Default TLS uses `rustls` with bundled webpki roots via the `tls-rustls`
feature. Platform-native TLS can be selected with `default-features = false`
and the `tls-platform-native` or `tls-platform-roots` feature. That backend
uses the operating system TLS stack on Windows and macOS, and OpenSSL on Linux.

## Versioning

The release version is defined in the root `Cargo.toml` under
`[workspace.package]`. Gradle projects derive their `group` and `version` from
that value, and `crates/takanawa-core/tests/workspace_versions.rs` verifies that
published version references stay in sync.

To bump the release version and sync published references, run:

```sh
mise run version:sync <version>
```

## npm

The `npm` GitHub Actions workflow publishes all non-private packages under
`packages/*` when a `v*` tag is pushed. This includes `takanawa-node`,
`takanawa-capacitor`, and `takanawa-tauri`. The private `takanawa-js-core`
package is bundled into those target packages at build time and is not published
separately. The workflow builds each package before `npm publish` so generated
`dist` files and package-specific native artifacts are included in the packed
tarball.

## Android

The Android SDK is published as:

```kotlin
dependencies {
    implementation("ai.yetanother:takanawa-android:0.7.3")
}
```

Basic usage:

```kotlin
Takanawa.init()
TakanawaDownload.create(
    DownloadConfig(
        url = "https://example.com/file.bin",
        targetPath = "/data/user/0/example/cache/file.bin",
    ),
).use { download ->
    download.start()
    val snapshot = download.snapshot()
}
Takanawa.shutdown()
```

Build and verify the local AAR:

```sh
mise run package:android-aar
```

Publish to Maven local and build the smoke app against the local coordinates:

```sh
mise run publish:android-local
```

Maven Central releases are published from the `Publish` GitHub Actions workflow
when a `v*` tag is pushed. Configure a GitHub Environment named
`maven-central` with these secrets:

- `MAVEN_CENTRAL_USERNAME`: Central Portal user token username.
- `MAVEN_CENTRAL_PASSWORD`: Central Portal user token password.
- `SIGNING_IN_MEMORY_KEY`: ASCII-armored private GPG key.
- `SIGNING_IN_MEMORY_KEY_ID`: GPG key id.
- `SIGNING_IN_MEMORY_KEY_PASSWORD`: optional GPG key password.

The release job builds the Android native libraries and runs:

```sh
./gradlew -Ptakanawa.skipRustBuild=true :takanawa-android:publishAndReleaseToMavenCentral
```

The Capacitor plugin does not publish a separate Maven artifact; its Android
bridge is distributed in the npm package and depends on `takanawa-android`.

## SwiftPM

The SwiftPM package is distributed as a prebuilt `Takanawa.xcframework`.
The current Apple deployment targets are iOS 13.0, iOS Simulator 13.0, and
macOS 10.15.
The static XCFramework links against Apple's CoreFoundation and Security
frameworks, plus libiconv.

```bash
mise run package:swiftpm
mise run test:swift-integration
mise run swiftpm:release-manifest
```

The checked-in `Package.swift` uses the local `target/apple/Takanawa.xcframework`
path so development and CI do not need to precompute a future release checksum.
Release builds generate `target/swiftpm/Package.swift` with the checksum for the
uploaded `Takanawa.xcframework.zip`.

The Capacitor plugin does not publish a separate SwiftPM plugin artifact. Its
iOS bridge and `Takanawa.xcframework` are bundled in the npm package, and
`packages/takanawa-capacitor/Package.swift` uses the bundled binary by default.

## C# and NuGet

The C# SDK is published as:

```xml
<PackageReference Include="YetAnotherAI.Takanawa" Version="0.6.0" />
```

Basic usage:

```csharp
using YetAnotherAI.Takanawa;

Takanawa.Init();
using var download = TakanawaDownload.Create(new DownloadConfig(
    url: "https://example.com/file.bin",
    targetPath: "/tmp/file.bin"));
download.Start();
var snapshot = download.Snapshot();
Takanawa.Shutdown();
```

The package targets `netstandard2.0` and includes managed bindings plus native
runtime assets for desktop, Android, and Apple targets. Build and test locally:

```sh
mise run test:csharp
```

Release packing expects staged native artifacts from the release workflow:

```sh
mise run pack:csharp
```

## C and C++

C and C++ consumers can link the C ABI library with CMake:

```cmake
add_subdirectory(path/to/takanawa)
target_link_libraries(app PRIVATE Takanawa::takanawa)
```

The same CMake package is available through the local vcpkg overlay port:

```sh
vcpkg install takanawa --overlay-ports=/path/to/takanawa/ports
```

Build the CMake smoke fixture:

```sh
mise run test:cmake-integration
```
