@tangle-network/starter-foundry 0.5.4 → 0.7.2

package/registry/families/triton-server/files/validate-triton.mjs

@@ -0,0 +1,53 @@
+import fs from "node:fs/promises";
+
+const [compose, requirements, client, config] = await Promise.all([
+  fs.readFile("docker-compose.yml", "utf8"),
+  fs.readFile("requirements.txt", "utf8"),
+  fs.readFile("src/client.py", "utf8"),
+  fs.readFile("model_repository/identity/config.pbtxt", "utf8"),
+]);
+
+if (!compose.includes("nvcr.io/nvidia/tritonserver")) {
+  throw new Error("docker-compose.yml missing nvcr.io/nvidia/tritonserver image");
+}
+if (!compose.includes("--model-repository")) {
+  throw new Error("docker-compose.yml must pass --model-repository to tritonserver");
+}
+if (!compose.includes("8000") || !compose.includes("8001") || !compose.includes("8002")) {
+  throw new Error("docker-compose.yml must expose Triton's HTTP(8000), gRPC(8001), metrics(8002)");
+}
+if (!compose.includes("driver: nvidia") || !compose.includes("capabilities: [gpu]")) {
+  throw new Error("docker-compose.yml missing nvidia GPU device reservation");
+}
+
+if (!requirements.includes("tritonclient")) {
+  throw new Error("requirements.txt missing tritonclient");
+}
+
+if (!client.includes("tritonclient")) {
+  throw new Error("src/client.py must import tritonclient");
+}
+if (!client.includes("InferInput") || !client.includes("InferRequestedOutput")) {
+  throw new Error("src/client.py must use InferInput/InferRequestedOutput");
+}
+if (!client.includes("is_server_ready") && !client.includes("is_model_ready")) {
+  throw new Error("src/client.py should check server/model readiness before inferring");
+}
+
+if (!config.includes("name:") || !config.includes("identity")) {
+  throw new Error("config.pbtxt missing name declaration");
+}
+if (!config.includes("input [") || !config.includes("output [")) {
+  throw new Error("config.pbtxt missing input/output tensor declarations");
+}
+if (!config.includes("max_batch_size")) {
+  throw new Error("config.pbtxt must declare max_batch_size");
+}
+
+// Verify version dir placeholder exists.
+const gitkeep = await fs.readFile("model_repository/identity/1/.gitkeep", "utf8").catch(() => null);
+if (gitkeep === null) {
+  throw new Error("model_repository/identity/1/.gitkeep missing — integer version dir is required");
+}
+
+console.log("triton starter ok");

package/registry/families/triton-server/manifest.json

@@ -0,0 +1,190 @@
+{
+  "id": "triton-server",
+  "description": "NVIDIA Triton Inference Server — multi-framework model serving (ONNX, TensorRT, PyTorch, Python backend, ensembles). Docker-compose scaffold with a model_repository layout, an identity/echo model for smoke-testing, and a tritonclient HTTP example. For serving classical ML (ResNet, Whisper, embeddings) and mixed ONNX/TensorRT pipelines at NVIDIA-optimized latency.",
+  "tags": [
+    "ml",
+    "inference",
+    "triton",
+    "nvidia",
+    "onnx",
+    "tensorrt",
+    "serving"
+  ],
+  "taxonomy": {
+    "language": "python",
+    "runtime": "python",
+    "surface": "inference"
+  },
+  "slots": {
+    "auth": {
+      "options": [
+        "auth:none",
+        "auth:better-auth",
+        "auth:clerk"
+      ],
+      "default": "auth:none"
+    }
+  },
+  "defaults": {
+    "projectType": "inference",
+    "serviceName": "starter-foundry-triton",
+    "port": 8000,
+    "grpcPort": 8001,
+    "metricsPort": 8002
+  },
+  "files": [
+    {
+      "source": "files/docker-compose.yml",
+      "target": "docker-compose.yml"
+    },
+    {
+      "source": "files/requirements.txt",
+      "target": "requirements.txt"
+    },
+    {
+      "source": "files/client.py",
+      "target": "src/client.py"
+    },
+    {
+      "source": "files/model_repository/identity/config.pbtxt",
+      "target": "model_repository/identity/config.pbtxt"
+    },
+    {
+      "source": "files/model_repository/identity/1/.gitkeep",
+      "target": "model_repository/identity/1/.gitkeep"
+    },
+    {
+      "source": "files/README-triton.md",
+      "target": "docs/triton.md"
+    },
+    {
+      "source": "files/validate-triton.mjs",
+      "target": "validate-triton.mjs"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "docker-compose.yml"
+    },
+    {
+      "type": "file-exists",
+      "path": "requirements.txt"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/client.py"
+    },
+    {
+      "type": "file-exists",
+      "path": "model_repository/identity/config.pbtxt"
+    },
+    {
+      "type": "command-success",
+      "command": [
+        "node",
+        "validate-triton.mjs"
+      ],
+      "expect": "triton starter ok"
+    }
+  ],
+  "contextHints": {
+    "commands": [
+      "docker compose up -d",
+      "pip install -r requirements.txt",
+      "python -m src.client",
+      "curl http://localhost:{{port}}/v2/health/ready"
+    ],
+    "entrypoints": [
+      "docker-compose.yml",
+      "model_repository/",
+      "src/client.py"
+    ],
+    "preview": {
+      "path": "/v2/health/ready",
+      "port": "{{port}}"
+    },
+    "extensionPoints": [
+      "model_repository/",
+      "src/client.py"
+    ]
+  },
+  "keywords": [
+    "triton",
+    "triton server",
+    "nvidia triton",
+    "tritonserver",
+    "triton inference server",
+    "model repository",
+    "onnx serving",
+    "tensorrt serving",
+    "ensemble model",
+    "triton http",
+    "triton grpc"
+  ],
+  "scoring": {
+    "boost": {
+      "triton": 4,
+      "nvidia triton": 4,
+      "onnx serving": 3,
+      "tensorrt serving": 3
+    }
+  },
+  "tieredKeywords": {
+    "tier1": [
+      "triton",
+      "nvidia triton",
+      "triton inference server",
+      "model repository"
+    ],
+    "tier2": [
+      "onnx serving",
+      "tensorrt serving",
+      "ensemble model",
+      "triton backend"
+    ],
+    "archetypes": [
+      "classical ml model serving",
+      "onnx production server",
+      "multi-framework model server",
+      "nvidia optimized inference"
+    ]
+  },
+  "buildHints": {
+    "whenToUse": "Pick Triton when the workload is classical ML (CV/ASR/embeddings/recommenders), when you're combining ONNX + TensorRT + Python backends in ensembles, or when NVIDIA-specific optimizations (TensorRT, CUDA graphs, dynamic batching) matter. For pure LLM serving use vllm-server / sglang-server / tgi-server — they're faster and simpler for that shape.",
+    "firstSteps": [
+      "Add a model: drop weights under model_repository/<name>/<version>/ (e.g. `model.onnx` or `model.plan`)",
+      "Write/edit model_repository/<name>/config.pbtxt — platform, inputs, outputs, dynamic_batching",
+      "docker compose up -d (pulls ~15GB — tritonserver image is large)",
+      "curl http://localhost:{{port}}/v2/health/ready — wait for HTTP 200",
+      "python -m src.client — infer against the identity model"
+    ],
+    "gotchas": [
+      "model_repository version directories MUST be integers (`1`, `2`, ...). Triton silently skips non-integer dirs like `v1` or `latest`.",
+      "config.pbtxt `platform` and `backend` are mutually exclusive per model. Pick one — e.g. `backend: \"onnxruntime\"` for ONNX, `platform: \"tensorrt_plan\"` for TRT plans.",
+      "Input tensor dims use `-1` for dynamic dims, `1` for batch. Getting this wrong returns opaque `inference failed` errors with no stack trace.",
+      "The HTTP endpoint is `/v2/` (KServe v2 spec), gRPC is on 8001. Legacy `/api/infer` docs refer to Triton v1 and do not apply.",
+      "Ensemble models in config.pbtxt require every sub-model listed in `ensemble_scheduling.step` to already be loaded — load order matters.",
+      "TRT engines (`.plan`) are built for a specific GPU + CUDA + TRT version. An engine built on A100 will not run on H100. Rebuild per deploy target.",
+      "The nvcr.io registry needs `docker login nvcr.io` for private variants; the public tritonserver image is unauthenticated."
+    ],
+    "placeholders": [
+      {
+        "path": "src/main.py",
+        "description": "model_repository/<name>/<version>/ — drop real model weights here"
+      },
+      {
+        "path": "src/main.py",
+        "description": "model_repository/<name>/config.pbtxt — declare inputs/outputs/batching"
+      },
+      {
+        "path": "src/main.py",
+        "description": "src/client.py — swap model_name + tensor shapes to match your model"
+      },
+      {
+        "path": "src/main.py",
+        "description": "docker-compose.yml — pin the tritonserver image tag (e.g. 24.10-py3)"
+      }
+    ]
+  }
+}

package/registry/families/unity-web-proxy/files/Build/.gitkeep

@@ -0,0 +1,17 @@
+# Unity WebGL build drop-zone.
+#
+# The editor's WebGL export writes into this directory:
+#
+#   Build/
+#     Build.loader.js
+#     Build.framework.js
+#     Build.wasm
+#     Build.data
+#     Build.symbols.json    (Development builds only)
+#
+# Filenames depend on Player Settings → Company Name / Product Name.
+# The loader URL in index.html (Build/Build.loader.js) must match.
+#
+# This .gitkeep preserves the directory in source control without
+# committing the generated artifacts. The sibling .gitignore excludes
+# everything else in here.

package/registry/families/unity-web-proxy/files/README.md

@@ -0,0 +1,68 @@
+# {{serviceName}}
+
+Unity WebGL build-host scaffold. The scaffold **does not contain the
+Unity editor output** — it provides the CI + serving harness to drop a
+Unity WebGL build into.
+
+## Layout
+
+```
+<this repo>
+  Build/            <- Unity editor's WebGL export drops here (gitignored)
+  scripts/
+    build-webgl.sh  <- Unity CLI batch-mode build script
+  index.html        <- Unity loader boot page
+  vite.config.ts    <- dev/preview server with COOP/COEP headers
+<elsewhere>
+  <unity-project>/  <- Assets/, ProjectSettings/, Library/, ...
+```
+
+The Unity project source lives elsewhere (a separate repo or a sibling
+directory). The CI script here invokes Unity in batch mode against it
+and writes output into `Build/`.
+
+## Local dev
+
+```sh
+pnpm install
+pnpm dev     # serves on 5173 with Cross-Origin-Opener-Policy +
+             # Cross-Origin-Embedder-Policy headers (required for
+             # Unity threads + SharedArrayBuffer)
+```
+
+Drop a Unity WebGL export into `Build/` first — `index.html` expects
+`Build/Build.loader.js`. The filename depends on Player Settings →
+Product Name; rename on both sides to match.
+
+## CI build
+
+```sh
+export UNITY_PROJECT_PATH=/path/to/unity-project
+export UNITY_VERSION=2022.3.42f1                    # Unity Hub-installed
+export UNITY_BUILD_METHOD=BuildScript.PerformWebGLBuild
+bash scripts/build-webgl.sh
+```
+
+The build method must exist in the Unity project (typically
+`Assets/Editor/Build.cs` with a `[MenuItem]` or static
+`BuildPlayerOptions` method). For GitHub Actions, use the
+`unityci/editor:ubuntu-<version>-webgl-<patch>` Docker image and
+pre-activate the license.
+
+## Gotchas
+
+- **SharedArrayBuffer headers.** Unity 2021.2+ WebGL builds enable
+  threads by default and require `Cross-Origin-Opener-Policy:
+  same-origin` + `Cross-Origin-Embedder-Policy: require-corp`. Vite's
+  server (`vite.config.ts`) sends these; production hosts must too.
+- **Compression.** Unity's `.br` (Brotli) and `.gz` (gzip) files need
+  the matching `Content-Encoding` response header. Static hosts that
+  strip headers will serve corrupted bundles. Either disable compression
+  in Player Settings → WebGL or verify with `curl -I`.
+- **Loader filenames.** `Build.loader.js` / `Build.framework.js` /
+  `Build.wasm` / `Build.data` derive from Player Settings → Product
+  Name. First editor export changes them; update `index.html` to match.
+- **License.** Batch-mode Unity requires an activated license.
+  CI without a license exits with code 12 after the 30-day trial.
+- **No multi-threaded GC.** WebGL builds use a single GC thread — long
+  pauses are visible as freezes. Keep per-frame allocations low.

package/registry/families/unity-web-proxy/files/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "{{packageName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "build:webgl": "bash scripts/build-webgl.sh",
+    "validate": "node validate-unity.mjs"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.0",
+    "vite": "^6.4.2"
+  },
+  "overrides": {
+    "vite": "^6.4.2"
+  },
+  "pnpm": {
+    "overrides": {
+      "vite": "^6.4.2"
+    }
+  }
+}

package/registry/families/unity-web-proxy/files/scripts/build-webgl.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# Unity WebGL batch-mode build. Runs the Unity editor headlessly against
+# a Unity project directory, invokes a C# build method, and writes
+# output into ./Build/.
+#
+# Requirements:
+#   - Unity Hub + the exact editor version pinned in ProjectVersion.txt
+#   - WebGL build support module installed for that editor
+#   - Unity license activated (Personal, Pro, Plus, or CI manual license)
+#   - Editor-side C# with `[MenuItem]` or `BuildPlayerOptions` method at
+#     BuildScript.PerformWebGLBuild (create one at
+#     Assets/Editor/Build.cs in the Unity project)
+#
+# Env vars:
+#   UNITY_PROJECT_PATH  absolute path to the Unity project source
+#   UNITY_VERSION       Unity version (e.g. 2022.3.42f1); used to
+#                       locate the editor binary
+#   UNITY_BUILD_METHOD  fully-qualified static C# method, default
+#                       BuildScript.PerformWebGLBuild
+
+set -euo pipefail
+
+: "${UNITY_PROJECT_PATH:?UNITY_PROJECT_PATH must point to the Unity project source}"
+: "${UNITY_VERSION:?UNITY_VERSION must be set (e.g. 2022.3.42f1)}"
+
+UNITY_BUILD_METHOD="${UNITY_BUILD_METHOD:-BuildScript.PerformWebGLBuild}"
+OUTPUT_DIR="$(pwd)/Build"
+
+# Locate the editor binary across macOS / Linux / CI Docker layouts.
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  UNITY_BIN="/Applications/Unity/Hub/Editor/${UNITY_VERSION}/Unity.app/Contents/MacOS/Unity"
+elif [[ -x "/opt/unity/Editor/Unity" ]]; then
+  UNITY_BIN="/opt/unity/Editor/Unity"   # unityci/editor Docker image
+else
+  UNITY_BIN="${HOME}/Unity/Hub/Editor/${UNITY_VERSION}/Editor/Unity"
+fi
+
+if [[ ! -x "$UNITY_BIN" ]]; then
+  echo "error: Unity editor binary not found at $UNITY_BIN" >&2
+  echo "       set UNITY_VERSION to a Unity Hub-installed editor" >&2
+  exit 1
+fi
+
+mkdir -p "$OUTPUT_DIR"
+
+echo "Unity: $UNITY_BIN"
+echo "Project: $UNITY_PROJECT_PATH"
+echo "Method: $UNITY_BUILD_METHOD"
+echo "Output: $OUTPUT_DIR"
+
+"$UNITY_BIN" \
+  -batchmode \
+  -nographics \
+  -quit \
+  -logFile - \
+  -projectPath "$UNITY_PROJECT_PATH" \
+  -executeMethod "$UNITY_BUILD_METHOD" \
+  -buildTarget WebGL \
+  -webglOutputPath "$OUTPUT_DIR" \
+  -silent-crashes
+
+echo "unity webgl build complete → $OUTPUT_DIR"

package/registry/families/unity-web-proxy/files/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"]
+  },
+  "include": ["vite.config.ts"]
+}

package/registry/families/unity-web-proxy/files/validate-unity.mjs

@@ -0,0 +1,60 @@
+// Structural validator for unity-web-proxy. Does NOT run Unity (requires
+// a licensed editor) and does NOT expect Build/*.wasm to exist (that's
+// the user's editor output). Confirms the scaffold wiring is consistent.
+
+import fs from "node:fs/promises";
+
+const [pkgSource, viteConfig, indexHtml, buildScript, readme] = await Promise.all([
+  fs.readFile("package.json", "utf8"),
+  fs.readFile("vite.config.ts", "utf8"),
+  fs.readFile("index.html", "utf8"),
+  fs.readFile("scripts/build-webgl.sh", "utf8"),
+  fs.readFile("README.md", "utf8"),
+]);
+
+const pkg = JSON.parse(pkgSource);
+if (pkg.name !== "{{packageName}}") {
+  throw new Error(`package.json name should be "{{packageName}}", got "${pkg.name}"`);
+}
+if (!pkg.devDependencies?.vite) {
+  throw new Error("package.json missing `vite` devDependency");
+}
+if (!pkg.scripts?.["build:webgl"]) {
+  throw new Error('package.json missing `build:webgl` script');
+}
+
+if (!viteConfig.includes("Cross-Origin-Opener-Policy")) {
+  throw new Error("vite.config.ts must set Cross-Origin-Opener-Policy header for Unity threads");
+}
+if (!viteConfig.includes("Cross-Origin-Embedder-Policy")) {
+  throw new Error("vite.config.ts must set Cross-Origin-Embedder-Policy header for Unity threads");
+}
+
+if (!indexHtml.includes("createUnityInstance")) {
+  throw new Error("index.html must call Unity's createUnityInstance() loader");
+}
+if (!/Build\/.*loader\.js/.test(indexHtml)) {
+  throw new Error('index.html must reference a Unity loader at Build/*.loader.js');
+}
+
+if (!buildScript.includes("-batchmode")) {
+  throw new Error("scripts/build-webgl.sh must invoke Unity with -batchmode");
+}
+if (!buildScript.includes("-buildTarget WebGL")) {
+  throw new Error("scripts/build-webgl.sh must pass -buildTarget WebGL");
+}
+if (!buildScript.includes("UNITY_PROJECT_PATH")) {
+  throw new Error("scripts/build-webgl.sh must honor UNITY_PROJECT_PATH");
+}
+
+try {
+  await fs.stat("Build/.gitkeep");
+} catch {
+  throw new Error("Build/.gitkeep must exist to preserve the drop-zone in VCS");
+}
+
+if (!readme.includes("SharedArrayBuffer") && !readme.includes("Cross-Origin")) {
+  throw new Error("README.md must document the COOP/COEP requirement for Unity WebGL");
+}
+
+console.log("unity-web-proxy starter ok");

package/registry/families/unity-web-proxy/files/vite.config.ts

@@ -0,0 +1,32 @@
+import { defineConfig } from 'vite'
+
+// Unity 2021.2+ WebGL builds ship with multi-threading enabled by
+// default, which requires SharedArrayBuffer, which requires the page to
+// be served with these two headers (cross-origin isolation). Without
+// them the Unity loader fails with a SharedArrayBuffer error before the
+// first frame.
+const crossOriginIsolation = {
+  'Cross-Origin-Opener-Policy': 'same-origin',
+  'Cross-Origin-Embedder-Policy': 'require-corp',
+}
+
+export default defineConfig({
+  server: {
+    port: 5173,
+    headers: crossOriginIsolation,
+    // Unity's .data files are large; don't warn on them.
+    fs: { strict: false },
+  },
+  preview: {
+    headers: crossOriginIsolation,
+  },
+  build: {
+    target: 'es2022',
+    // The Unity Build/ directory is shipped as static assets — copy it
+    // into dist/ on build so production serves the same layout.
+    assetsInlineLimit: 0,
+  },
+  // Don't let Vite try to transform Unity's .framework.js or .wasm
+  // bundles — they're pre-built by Unity and byte-identical.
+  assetsInclude: ['**/*.wasm', '**/*.data', '**/*.symbols.json'],
+})