@tangle-network/starter-foundry 0.5.4 → 0.7.0

package/registry/families/kotlin-multiplatform/files/build.gradle.kts

@@ -0,0 +1,67 @@
+import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    kotlin("multiplatform") version "2.0.21"
+    id("com.android.library") version "8.5.2"
+    id("org.jetbrains.compose") version "1.7.0"
+    id("org.jetbrains.kotlin.plugin.compose") version "2.0.21"
+}
+
+kotlin {
+    androidTarget {
+        @OptIn(ExperimentalKotlinGradlePluginApi::class)
+        compilerOptions {
+            jvmTarget.set(JvmTarget.JVM_17)
+        }
+    }
+
+    listOf(
+        iosX64(),
+        iosArm64(),
+        iosSimulatorArm64(),
+    ).forEach { iosTarget ->
+        iosTarget.binaries.framework {
+            baseName = "Shared"
+            isStatic = true
+        }
+    }
+
+    sourceSets {
+        val commonMain by getting {
+            dependencies {
+                implementation(compose.runtime)
+                implementation(compose.foundation)
+                implementation(compose.material3)
+                implementation(compose.ui)
+                implementation(compose.components.resources)
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
+            }
+        }
+        val commonTest by getting {
+            dependencies {
+                implementation(kotlin("test"))
+            }
+        }
+        val androidMain by getting {
+            dependencies {
+                implementation("androidx.activity:activity-compose:1.9.3")
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0")
+            }
+        }
+    }
+}
+
+android {
+    namespace = "com.starterfoundry.{{packageName}}.shared"
+    compileSdk = 34
+
+    defaultConfig {
+        minSdk = 24
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+}

package/registry/families/kotlin-multiplatform/files/gradle.properties

@@ -0,0 +1,12 @@
+org.gradle.jvmargs=-Xmx4g -Dfile.encoding=UTF-8
+org.gradle.parallel=true
+org.gradle.caching=true
+org.gradle.configuration-cache=true
+
+kotlin.code.style=official
+kotlin.mpp.enableCInteropCommonization=true
+kotlin.mpp.applyDefaultHierarchyTemplate=true
+kotlin.native.ignoreDisabledTargets=true
+
+android.useAndroidX=true
+android.nonTransitiveRClass=true

package/registry/families/kotlin-multiplatform/files/root-build.gradle.kts

@@ -0,0 +1,12 @@
+// Top-level build file. Plugin versions are declared in each subproject's
+// build.gradle.kts via plugin DSL (e.g. shared/build.gradle.kts). This keeps
+// root config minimal so subprojects can evolve independently.
+
+plugins {
+    // Declared but not applied — subprojects apply what they need.
+    kotlin("multiplatform") version "2.0.21" apply false
+    id("com.android.application") version "8.5.2" apply false
+    id("com.android.library") version "8.5.2" apply false
+    id("org.jetbrains.compose") version "1.7.0" apply false
+    id("org.jetbrains.kotlin.plugin.compose") version "2.0.21" apply false
+}

package/registry/families/kotlin-multiplatform/files/settings.gradle.kts

@@ -0,0 +1,30 @@
+rootProject.name = "{{packageName}}"
+
+pluginManagement {
+    repositories {
+        google {
+            mavenContent {
+                includeGroupAndSubgroups("androidx")
+                includeGroupAndSubgroups("com.android")
+                includeGroupAndSubgroups("com.google")
+            }
+        }
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+dependencyResolutionManagement {
+    repositories {
+        google {
+            mavenContent {
+                includeGroupAndSubgroups("androidx")
+                includeGroupAndSubgroups("com.android")
+                includeGroupAndSubgroups("com.google")
+            }
+        }
+        mavenCentral()
+    }
+}
+
+include(":shared")

package/registry/families/kotlin-multiplatform/files/validate-kmp.mjs

@@ -0,0 +1,52 @@
+// Structural validator for the kotlin-multiplatform starter. Does NOT invoke
+// Gradle (which needs the full Kotlin + Android + Xcode toolchain). Confirms
+// the shared module wires expect/actual correctly and Compose Multiplatform
+// is declared in the right places.
+
+import fs from "node:fs/promises";
+
+const [settings, sharedBuild, rootBuild, appKt, platformAndroid, platformIos] = await Promise.all([
+  fs.readFile("settings.gradle.kts", "utf8"),
+  fs.readFile("shared/build.gradle.kts", "utf8"),
+  fs.readFile("build.gradle.kts", "utf8"),
+  fs.readFile("shared/src/commonMain/kotlin/App.kt", "utf8"),
+  fs.readFile("shared/src/androidMain/kotlin/Platform.android.kt", "utf8"),
+  fs.readFile("shared/src/iosMain/kotlin/Platform.ios.kt", "utf8"),
+]);
+
+if (!settings.includes('include(":shared")')) {
+  throw new Error("settings.gradle.kts must include the :shared module");
+}
+
+if (!sharedBuild.includes('kotlin("multiplatform")')) {
+  throw new Error("shared/build.gradle.kts must apply the kotlin multiplatform plugin");
+}
+if (!sharedBuild.includes("org.jetbrains.compose")) {
+  throw new Error("shared/build.gradle.kts must apply the Compose Multiplatform plugin");
+}
+if (!sharedBuild.includes("iosArm64()") || !sharedBuild.includes("iosSimulatorArm64()")) {
+  throw new Error("shared/build.gradle.kts must declare iosArm64 + iosSimulatorArm64 targets");
+}
+if (!sharedBuild.includes("androidTarget")) {
+  throw new Error("shared/build.gradle.kts must declare an androidTarget");
+}
+
+if (!rootBuild.includes('apply false')) {
+  throw new Error("Root build.gradle.kts must declare plugins with `apply false` so subprojects apply them");
+}
+
+if (!appKt.includes("@Composable")) {
+  throw new Error("commonMain/App.kt must export a @Composable App() surface");
+}
+if (!appKt.includes("expect ") && !appKt.includes("expect\n")) {
+  throw new Error("commonMain/App.kt must declare at least one `expect` platform function");
+}
+
+if (!platformAndroid.includes("actual ")) {
+  throw new Error("androidMain/Platform.android.kt must provide `actual` implementations");
+}
+if (!platformIos.includes("actual ")) {
+  throw new Error("iosMain/Platform.ios.kt must provide `actual` implementations");
+}
+
+console.log("kotlin-multiplatform starter ok");

package/registry/families/kotlin-multiplatform/manifest.json

@@ -0,0 +1,196 @@
+{
+  "id": "kotlin-multiplatform",
+  "description": "Kotlin Multiplatform (KMP) + Compose Multiplatform starter \u2014 one Kotlin codebase targeting Android, iOS, and desktop with shared UI in Compose. Uses the expect/actual pattern for platform-specific APIs and Gradle Kotlin DSL for the build. For teams that want Jetpack Compose on iOS, not Dart (Flutter) or Swift.",
+  "tags": [
+    "kotlin",
+    "multiplatform",
+    "compose",
+    "mobile",
+    "android",
+    "ios"
+  ],
+  "taxonomy": {
+    "language": "kotlin",
+    "runtime": "kotlin-multiplatform",
+    "surface": "mobile"
+  },
+  "slots": {
+    "auth": {
+      "options": [
+        "auth:none",
+        "auth:better-auth",
+        "auth:clerk",
+        "auth:supabase-auth"
+      ],
+      "default": "auth:none"
+    },
+    "payments": {
+      "options": [
+        "payments:none",
+        "payments:stripe",
+        "payments:coinbase-commerce"
+      ],
+      "default": "payments:none"
+    },
+    "sdk": {
+      "options": [
+        "sdk:none",
+        "sdk:coinbase-cdp",
+        "sdk:solana-web3",
+        "sdk:evm-wallet"
+      ],
+      "default": "sdk:none"
+    }
+  },
+  "defaults": {
+    "projectType": "mobile",
+    "headline": "Starter Foundry KMP App",
+    "subheadline": "A Kotlin Multiplatform shell with Compose UI shared across Android and iOS, plus expect/actual platform seams."
+  },
+  "files": [
+    {
+      "source": "files/build.gradle.kts",
+      "target": "shared/build.gradle.kts"
+    },
+    {
+      "source": "files/settings.gradle.kts",
+      "target": "settings.gradle.kts"
+    },
+    {
+      "source": "files/gradle.properties",
+      "target": "gradle.properties"
+    },
+    {
+      "source": "files/root-build.gradle.kts",
+      "target": "build.gradle.kts"
+    },
+    {
+      "source": "files/validate-kmp.mjs",
+      "target": "validate-kmp.mjs"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "settings.gradle.kts"
+    },
+    {
+      "type": "file-exists",
+      "path": "shared/build.gradle.kts"
+    },
+    {
+      "type": "file-exists",
+      "path": "shared/src/commonMain/kotlin/App.kt"
+    },
+    {
+      "type": "command-success",
+      "command": [
+        "node",
+        "validate-kmp.mjs"
+      ],
+      "expect": "kotlin-multiplatform starter ok"
+    }
+  ],
+  "contextHints": {
+    "commands": [
+      "./gradlew :shared:build",
+      "./gradlew :shared:iosSimulatorArm64Test",
+      "./gradlew :androidApp:installDebug",
+      "node validate-kmp.mjs"
+    ],
+    "entrypoints": [
+      "shared/src/commonMain/kotlin/App.kt",
+      "shared/src/androidMain/kotlin/Platform.android.kt",
+      "shared/src/iosMain/kotlin/Platform.ios.kt",
+      "shared/build.gradle.kts",
+      "settings.gradle.kts"
+    ],
+    "preview": null,
+    "extensionPoints": [
+      "shared/src/commonMain/kotlin/",
+      "auth-config.json",
+      "payments-config.json",
+      "sdk-config.json"
+    ]
+  },
+  "keywords": [
+    "kotlin",
+    "kotlin multiplatform",
+    "kmp",
+    "compose multiplatform",
+    "jetpack compose",
+    "expect actual",
+    "kotlin ios",
+    "kotlin android",
+    "multiplatform mobile",
+    "gradle kotlin dsl"
+  ],
+  "scoring": {
+    "boost": {
+      "kmp": 3,
+      "kotlin multiplatform": 3,
+      "compose multiplatform": 3,
+      "expect actual": 2,
+      "expect-actual": 2
+    }
+  },
+  "tieredKeywords": {
+    "tier1": [
+      "kotlin multiplatform",
+      "kmp",
+      "compose multiplatform",
+      "expect-actual",
+      "expect actual"
+    ],
+    "tier2": [
+      "jetpack compose",
+      "kotlin ios",
+      "kotlin android",
+      "multiplatform mobile",
+      "gradle kotlin dsl"
+    ],
+    "archetypes": [
+      "kmp mobile app",
+      "compose multiplatform app",
+      "kotlin shared ui ios android",
+      "single kotlin codebase mobile"
+    ]
+  },
+  "buildHints": {
+    "whenToUse": "Pick kotlin-multiplatform when the user names KMP, Kotlin Multiplatform, Compose Multiplatform, `expect`/`actual`, or wants Jetpack Compose on iOS. For Google's Dart-based equivalent use flutter-app. For JS-driven mobile use expo-react-native-ts. For iOS-only SwiftUI use swiftui-expo.",
+    "firstSteps": [
+      "Install JDK 17+, Android Studio (Giraffe+), and Xcode 15+ on a Mac (iOS target needs macOS)",
+      "Run `./gradlew :shared:build` to confirm the shared module compiles across all targets",
+      "Add Android app module under androidApp/ and iOS app under iosApp/ \u2014 the `shared` library is consumed from both",
+      "For iOS: `./gradlew :shared:podPublishXCFramework` (or use the Kotlin Cocoapods plugin)",
+      "Add new platform APIs via the expect/actual pattern \u2014 define `expect` in commonMain, provide `actual` in androidMain + iosMain"
+    ],
+    "gotchas": [
+      "iOS targets require building on macOS with Xcode; Linux/Windows machines can only build Android + desktop targets.",
+      "Compose Multiplatform 1.7+ ships @Composable for iOS but a few Material APIs are still desktop/Android-only \u2014 check expect/actual coverage.",
+      "Gradle daemon + Kotlin/Native compilation are memory-hungry \u2014 bump org.gradle.jvmargs to at least -Xmx4g in gradle.properties.",
+      "Kotlin/Native freezes objects across threads in legacy memory model; this template targets the new memory model (default in Kotlin 1.9+) \u2014 DO NOT re-enable kotlin.native.binary.memoryModel=strict.",
+      "`expect` declarations must be matched by an `actual` in EVERY target source set \u2014 missing an actual in iosMain fails the iOS build only."
+    ],
+    "architectureNotes": [
+      "shared/src/commonMain/kotlin/App.kt hosts the shared @Composable App() surface \u2014 this is what both androidApp and iosApp render.",
+      "Platform APIs (clipboard, secure storage, biometrics) go behind `expect fun platform(): Platform` in commonMain with `actual` implementations in androidMain + iosMain.",
+      "auth/payments/sdk slots drop JSON config at the repo root. A bootstrap function in commonMain reads those and dispatches to the right platform service via expect/actual.",
+      "Gradle KTS is the build contract \u2014 don't mix Groovy `.gradle` and Kotlin `.gradle.kts` files; it breaks IDE navigation and composite builds."
+    ],
+    "placeholders": [
+      {
+        "path": "shared/src/commonMain/kotlin/App.kt",
+        "description": "{{packageName}} \u2014 maps to gradle rootProject.name + applicationId base (kebab-case)"
+      },
+      {
+        "path": "shared/src/commonMain/kotlin/App.kt",
+        "description": "{{projectName}} \u2014 display name in Compose Multiplatform App() title"
+      },
+      {
+        "path": "shared/src/commonMain/kotlin/App.kt",
+        "description": "{{headline}} + {{subheadline}} \u2014 rendered on the shared home composable"
+      }
+    ]
+  }
+}

package/registry/families/kyc-onboarding/files/.env.example

@@ -0,0 +1,6 @@
+# KYC provider selection. Values: 'sandbox' (local mock) or 'persona', 'sumsub', etc.
+# The UI reads this via import.meta.env.VITE_KYC_PROVIDER.
+VITE_KYC_PROVIDER=sandbox
+
+# Provider API key — inject at runtime, never commit real values.
+# VITE_KYC_API_KEY=your-provider-key

package/registry/families/kyc-onboarding/files/README.md

@@ -0,0 +1,23 @@
+# KYC Onboarding Starter
+This starter is derived from 5× real demand signal and is designed to provide a basic structure for KYC onboarding applications.
+## Taxonomy
+* Language: TypeScript
+* Runtime: Node
+* Surface: Frontend
+## Getting Started
+To get started with this starter, please follow these steps:
+1. Install the required dependencies by running `npm install` or `yarn install` in your terminal.
+2. Start the development server by running `npm run dev` or `yarn dev`.
+3. Open your web browser and navigate to `http://localhost:3000` to view the application.
+## Agent-Facing Extension Guide
+This starter also provides a basic structure for agent-facing extensions. To create an extension, please follow these steps:
+1. Create a new file in the `src` directory and add your extension code.
+2. Import the required dependencies and register your extension with the application.
+3. Start the development server and test your extension.
+## Peer Families
+This starter is part of a larger family of starters, including:
+* Angular TS: Angular TypeScript starter with standalone components and signals.
+* Astro Static: Astro 5.x static site starter with islands architecture, zero-JS by default, Vite-powered dev server, and MDX-ready content.
+* Next.js TS: Next.js ready TypeScript starter with instant preview shell.
+* Observable Notebook: Observable Framework starter with reactive data-app SSG that renders Markdown with JavaScript data loaders into a static site, no server runtime in production.
+* Phaser Game: Phaser 3 2D game starter on Vite with arcade physics, one scene, sprite-first game loop with input + update + resize wired from first render.

package/registry/families/kyc-onboarding/files/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+    <title>KYC onboarding</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

package/registry/families/kyc-onboarding/files/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "kyc-onboarding",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc --noEmit && vite build",
+    "preview": "vite preview",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "@vitejs/plugin-react": "^4.3.3",
+    "typescript": "^5.6.3",
+    "vite": "^5.4.10",
+    "vitest": "^2.1.4"
+  }
+}

package/registry/families/kyc-onboarding/files/src/App.tsx

@@ -0,0 +1,40 @@
+import { useState } from 'react'
+
+type Step = 'start' | 'document' | 'selfie' | 'review' | 'done'
+
+export function App() {
+  const [step, setStep] = useState<Step>('start')
+  const kycProvider = import.meta.env.VITE_KYC_PROVIDER ?? 'sandbox'
+
+  return (
+    <main style={{ maxWidth: 560, margin: '3rem auto', fontFamily: 'system-ui' }}>
+      <h1>KYC onboarding</h1>
+      <p style={{ color: '#666' }}>Provider: <code>{kycProvider}</code></p>
+      {step === 'start' && (
+        <button onClick={() => setStep('document')}>Start verification</button>
+      )}
+      {step === 'document' && (
+        <section>
+          <h2>1. Upload document</h2>
+          <p>Drop a government-issued ID. Extension points: replace with your KYC provider SDK.</p>
+          <button onClick={() => setStep('selfie')}>Continue</button>
+        </section>
+      )}
+      {step === 'selfie' && (
+        <section>
+          <h2>2. Liveness check</h2>
+          <p>Capture a selfie for liveness. Hook your provider's capture widget here.</p>
+          <button onClick={() => setStep('review')}>Continue</button>
+        </section>
+      )}
+      {step === 'review' && (
+        <section>
+          <h2>3. Review</h2>
+          <p>Submitted — waiting for provider decision.</p>
+          <button onClick={() => setStep('done')}>Simulate approval</button>
+        </section>
+      )}
+      {step === 'done' && <p>✓ Verified. Next: call your backend to mint user credentials.</p>}
+    </main>
+  )
+}

package/registry/families/kyc-onboarding/files/src/main.ts

@@ -0,0 +1,12 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import { App } from './App'
+
+const root = document.getElementById('root')
+if (!root) throw new Error('missing #root — index.html must contain <div id="root">')
+
+createRoot(root).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

package/registry/families/kyc-onboarding/files/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "allowImportingTsExtensions": false,
+    "noEmit": true,
+    "lib": ["es2022", "dom", "dom.iterable"],
+    "types": ["vite/client"]
+  },
+  "include": ["src", "vite.config.ts"]
+}

package/registry/families/kyc-onboarding/files/validate-node.mjs

@@ -0,0 +1,17 @@
+export function validateNode(files, deps) {
+  // Validate key files
+  if (!files.includes('index.mjs')) {
+    throw new Error('Index file not found');
+  }
+  if (!files.includes('package.json')) {
+    throw new Error('Package file not found');
+  }
+
+  // Validate dependencies
+  if (!deps.includes('typescript')) {
+    throw new Error('Typescript dependency not found');
+  }
+  if (!deps.includes('node')) {
+    throw new Error('Node dependency not found');
+  }
+}

package/registry/families/kyc-onboarding/files/vite.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [react()],
+  base: './',
+  server: {
+    port: 3000
+  },
+  esbuild: {
+    loader: 'es2022',
+    target: 'es2022'
+  }
+})