@tangle-network/starter-foundry 0.5.4 → 0.7.0

package/registry/layers/framework/observable-notebook/manifest.json

@@ -0,0 +1,55 @@
+{
+  "id": "observable-notebook",
+  "description": "Observable Framework layer: overview page demonstrating a JavaScript data loader and Plot chart.",
+  "appliesTo": ["observable-notebook"],
+  "files": [
+    { "source": "files/tsconfig.json", "target": "tsconfig.json" },
+    { "source": "files/src/observablehq.d.ts", "target": "src/observablehq.d.ts" },
+    { "source": "files/overview.md", "target": "src/overview.md" },
+    { "source": "files/data/rows.json.ts", "target": "src/data/rows.json.ts" }
+  ],
+  "packageDeps": {
+    "dependencies": {
+      "@observablehq/framework": "^1.13.0"
+    },
+    "devDependencies": {
+      "typescript": "^5.7.0",
+      "@types/node": "^20.0.0"
+    }
+  },
+  "buildHints": {
+    "whenToUse": "Interactive data dashboards, analytics UIs, internal reporting tools, or any project where markdown-first reactive notebooks are the primary surface.",
+    "firstSteps": [
+      "Run `pnpm install` then `pnpm dev` — Observable Framework serves on port 3000 with HMR; the home page renders immediately.",
+      "Pages live in `src/` as `.md` files — `src/index.md` is the home page, `src/overview.md` is the demo Overview page.",
+      "Data loaders live in `src/data/` — `src/data/rows.json.ts` runs at build time and its JSON output is consumed in `overview.md` via `FileAttachment`.",
+      "Run `pnpm build` to emit a fully-static site to `dist/` — no server runtime in production, deploy to any CDN."
+    ],
+    "gotchas": [
+      "`Plot` and `Inputs` are Observable Framework globals in `.md` pages — do NOT import them; adding an explicit import will cause a runtime error.",
+      "Data loaders run at build time (and dev-server boot), not in the browser — they have full Node.js access but must write JSON, CSV, or plain text to stdout.",
+      "The `observablehq.config.ts` `pages` array controls sidebar navigation — add a new entry whenever you add a new `.md` file in `src/`.",
+      "TypeScript in `.md` fenced code blocks is not typechecked by `tsc` — only `observablehq.config.ts` and explicit `src/**/*.ts` files are covered."
+    ],
+    "architectureNotes": [
+      "Each `.md` page is an isolated reactive notebook — JavaScript cells run top-to-bottom and can reference earlier cells by name.",
+      "Data loaders decouple heavy computation from the browser — run SQL, Node scripts, or any subprocess as a loader and ship only the serialised output."
+    ],
+    "placeholders": [
+      {
+        "path": "src/data/rows.json.ts",
+        "description": "Synthetic monthly-revenue data loader. Replace the generated array with a real database query or API fetch; keep the `process.stdout.write(JSON.stringify(...))` call so Observable Framework picks up the output."
+      },
+      {
+        "path": "src/overview.md",
+        "description": "Demo overview page backed by the rows.json data loader. Swap in domain-specific metrics, rename columns, and adjust the Plot mark type to match the actual data shape."
+      }
+    ]
+  },
+  "contextHints": {
+    "commands": ["pnpm install", "pnpm dev", "pnpm build"],
+    "entrypoints": ["observablehq.config.ts", "src/index.md", "src/overview.md"],
+    "preview": { "port": "3000", "path": "/" },
+    "extensionPoints": ["src/data/", "src/components/", "src/overview.md"]
+  }
+}

package/registry/layers/framework/ollama-server/files/.env.example

@@ -0,0 +1,6 @@
+# Ollama server base URL. Override to point at a remote or differently-mapped instance.
+OLLAMA_BASE_URL=http://localhost:11434
+
+# Model to use for inference. Must be pulled first:
+#   docker compose exec ollama ollama pull llama3.2
+OLLAMA_MODEL=llama3.2

package/registry/layers/framework/ollama-server/files/src/client.ts

@@ -0,0 +1,52 @@
+// Minimal streaming client for a local Ollama server.
+// Replace the prompt + response handler with the product's actual LLM call flow.
+
+const BASE_URL = process.env['OLLAMA_BASE_URL'] ?? 'http://localhost:11434'
+const MODEL = process.env['OLLAMA_MODEL'] ?? 'llama3.2'
+
+interface GenerateChunk {
+  response?: string
+  done: boolean
+  total_duration?: number
+  eval_count?: number
+}
+
+async function generate(prompt: string): Promise<void> {
+  const res = await fetch(`${BASE_URL}/api/generate`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ model: MODEL, prompt, stream: true }),
+  })
+
+  if (!res.ok || !res.body) throw new Error(`ollama /api/generate ${res.status}`)
+
+  const reader = res.body.getReader()
+  const decoder = new TextDecoder()
+  let buffer = ''
+  let tokens = 0
+
+  while (true) {
+    const { value, done } = await reader.read()
+    if (done) break
+    buffer += decoder.decode(value, { stream: true })
+    // NDJSON: split on newline, keep the trailing partial line.
+    const lines = buffer.split('\n')
+    buffer = lines.pop() ?? ''
+    for (const line of lines) {
+      if (!line) continue
+      const chunk = JSON.parse(line) as GenerateChunk
+      if (chunk.response) {
+        process.stdout.write(chunk.response)
+        tokens++
+      }
+      if (chunk.done) {
+        process.stdout.write(`\n\n[${tokens} tokens, ${Math.round((chunk.total_duration ?? 0) / 1e6)}ms]\n`)
+      }
+    }
+  }
+}
+
+generate('Explain starter-foundry in one sentence.').catch((err) => {
+  console.error(err)
+  process.exit(1)
+})

package/registry/layers/framework/ollama-server/manifest.json

@@ -0,0 +1,52 @@
+{
+  "id": "ollama-server",
+  "description": "Ollama framework layer — streaming NDJSON TypeScript client for /api/generate with line-buffered chunk parsing.",
+  "appliesTo": ["ollama-server"],
+  "files": [
+    { "source": "files/src/client.ts", "target": "src/client.ts" },
+    { "source": "files/.env.example", "target": ".env.example" }
+  ],
+  "packageDeps": {
+    "devDependencies": {
+      "@types/node": "^22.0.0"
+    }
+  },
+  "buildHints": {
+    "whenToUse": "Self-hosted / local LLM inference where privacy, offline operation, or zero-vendor-cost matter. Use over cloud LLM layers when data must stay on-prem or when targeting laptops and air-gapped environments.",
+    "firstSteps": [
+      "Start Ollama: `docker compose up -d` — binds port 11434 on the host. CPU-only by default; uncomment the GPU block in docker-compose.yml for CUDA.",
+      "Pull a model (one-time): `docker compose exec ollama ollama pull llama3.2` (~2-8 GB). Other options: qwen2.5, mistral, gemma3.",
+      "Install deps and run: `pnpm install && pnpm dev` — `src/client.ts` calls /api/generate and streams the response to stdout.",
+      "Customize the persona: edit `Modelfile` (FROM, SYSTEM, PARAMETER temperature/stop), then `ollama create mymodel -f Modelfile` inside the container.",
+      "Verify: `curl http://localhost:11434/api/tags` lists loaded models; `pnpm typecheck` must pass with zero errors."
+    ],
+    "gotchas": [
+      "The Ollama response stream is NDJSON, not SSE — each chunk is a JSON line. The client buffers partial lines across `read()` calls; do not replace the line-split logic with a single `JSON.parse` on the raw chunk.",
+      "Models are pulled at runtime, not baked into the image. A fresh container returns an error (not a hang) for an unpulled model — always pull before calling /api/generate.",
+      "`@types/node` is required for `process.stdout.write` and `process.exit` — it is declared in this layer's packageDeps and must remain in devDependencies.",
+      "GPU inference requires both `deploy.resources.reservations.devices` in docker-compose.yml AND nvidia-container-toolkit on the host. Missing either silently falls back to slow CPU mode."
+    ],
+    "architectureNotes": [
+      "Replace the example prompt in `src/client.ts` and the stdout handler with the product's actual call flow — the streaming loop and NDJSON parser are production-ready and should be kept.",
+      "For chat (multi-turn), switch the endpoint to /api/chat and pass a `messages` array instead of a flat `prompt` string; the NDJSON framing is identical."
+    ],
+    "placeholders": [
+      {
+        "path": "src/client.ts",
+        "description": "Example client calling /api/generate with a hardcoded prompt. Replace the prompt string and stdout handler with the product's actual LLM call flow. Keep the streaming loop and NDJSON parser."
+      }
+    ]
+  },
+  "contextHints": {
+    "commands": [
+      "docker compose up -d",
+      "docker compose exec ollama ollama pull llama3.2",
+      "pnpm install",
+      "pnpm dev",
+      "pnpm typecheck"
+    ],
+    "entrypoints": ["src/client.ts"],
+    "preview": { "path": "/api/tags", "port": "11434" },
+    "extensionPoints": ["src/client.ts", ".env.example", "Modelfile", "docker-compose.yml"]
+  }
+}

package/registry/layers/framework/pci-dss-compliance-pack/files/AGENTS.md

@@ -0,0 +1,52 @@
+# PCI DSS Compliance Pack — Agent Guide
+
+Scope-reducing primitives for a Stripe-backed commerce backend. The PAN never
+reaches your server; all CHD is handled by Stripe Elements on the client side.
+
+## Quick start
+
+```bash
+pnpm install
+pnpm build     # runs tsc --noEmit; zero errors is the bar
+node validate-pci-pack.mjs   # prints "pci-pack ok" when scaffold is intact
+```
+
+## Module map
+
+| File | Exports | Purpose |
+|------|---------|---------|
+| `src/pan-redact.ts` | `redactPan`, `redactPanInObject` | Replace Luhn-valid PANs with `<pan-redacted:****NNNN>` |
+| `src/tokenize.ts` | `assertNoChdInRef`, `summarizePaymentMethod`, `StripePaymentMethodRef` | Validate + log Stripe `pm_…` token refs |
+| `src/index.ts` | re-exports all of the above | Single import surface |
+
+## Critical rules
+
+- **Never store CVV** post-authorization — PCI DSS 3.2.1 forbids it even encrypted.
+- **Never log raw bodies** on payment endpoints without running `redactPanInObject()` first.
+- **Never accept PANs via GET** — always POST; PANs in URLs land in access logs.
+- Use Stripe `pm_…` tokens as the only card reference stored in your database.
+
+## Wiring redaction
+
+```typescript
+import { redactPanInObject } from './pan-redact.js'
+
+// Sentry (before SDK init)
+Sentry.init({
+  beforeSend(event) {
+    return redactPanInObject(event)
+  },
+})
+
+// Express request logger
+app.use((req, _res, next) => {
+  req.body = redactPanInObject(req.body)
+  next()
+})
+```
+
+## Extending
+
+- Add BIN ranges specific to your processor in `src/pan-redact.ts` — extend `PAN_PATTERN`.
+- CHD-scoped audit events: emit to a separate log sink (e.g. a dedicated table or stream) so general app logs never mix with PCI audit scope.
+- Validate the scaffold stays intact with `node validate-pci-pack.mjs` in CI.

package/registry/layers/framework/pci-dss-compliance-pack/files/README.md

@@ -0,0 +1,51 @@
+# PCI DSS Compliance Pack
+
+PCI DSS 4.0 primitives for a Stripe-backed commerce backend. Stripe Elements handles the PAN client-side — this pack keeps your server out of CHD scope.
+
+## Quick start
+
+```bash
+pnpm install
+pnpm build               # tsc --noEmit — zero errors means scaffold is wired
+node validate-pci-pack.mjs   # prints "pci-pack ok"
+```
+
+## What's included
+
+| File | Purpose |
+|------|---------|
+| `src/pan-redact.ts` | Replace Luhn-valid PANs with `<pan-redacted:****NNNN>` in logs and error tracers |
+| `src/tokenize.ts` | Server-side contract for Stripe `pm_…` token refs — validate, assert, summarize |
+| `src/index.ts` | Barrel re-export of the full public surface |
+| `docs/PCI-DSS-controls.md` | Control mapping and compliance notes |
+
+## Usage
+
+```typescript
+import { redactPanInObject, assertNoChdInRef, summarizePaymentMethod } from './src/index.js'
+
+// Wire redaction onto every log sink
+app.use((req, _res, next) => {
+  req.body = redactPanInObject(req.body)
+  next()
+})
+
+// Validate a Stripe payment method ref before storing it
+assertNoChdInRef(ref)          // throws if a raw PAN leaked in
+console.log(summarizePaymentMethod(ref))  // "visa ****4242 (pm_...)"
+```
+
+## Critical rules
+
+- **Never store CVV** post-authorization — PCI DSS 3.2.1 forbids it, even encrypted.
+- **Never log request bodies** on payment endpoints without `redactPanInObject()`.
+- **Never accept PANs via GET** — always POST; PANs in URLs land in access logs.
+- Store only the Stripe `pm_…` token as the card reference in your database.
+
+## Validation
+
+```bash
+node validate-pci-pack.mjs
+```
+
+Run this in CI to confirm the scaffold files and exports are intact. Exits non-zero and prints what's missing if the pack is broken.

package/registry/layers/framework/pci-dss-compliance-pack/files/src/index.ts

@@ -0,0 +1,3 @@
+export { redactPan, redactPanInObject } from './pan-redact.js'
+export type { StripePaymentMethodRef } from './tokenize.js'
+export { assertNoChdInRef, summarizePaymentMethod } from './tokenize.js'

package/registry/layers/framework/pci-dss-compliance-pack/manifest.json

@@ -0,0 +1,50 @@
+{
+  "id": "pci-dss-compliance-pack",
+  "description": "PCI DSS 4.0 compliance overlay — CHD tokenization, PAN redaction, and audit primitives for Stripe-backed commerce backends.",
+  "appliesTo": ["pci-dss-compliance-pack"],
+  "files": [
+    { "source": "files/src/index.ts", "target": "src/index.ts" },
+    { "source": "files/AGENTS.md", "target": "AGENTS.md" },
+    { "source": "files/README.md", "target": "README.md" }
+  ],
+  "packageDeps": {
+    "devDependencies": {
+      "typescript": "^5.9.0",
+      "@types/node": "^22.0.0"
+    }
+  },
+  "buildHints": {
+    "whenToUse": "Adding PCI DSS 4.0 primitives (CHD tokenization, PAN redaction) to a commerce backend. Reduces SAQ scope when paired with Stripe Checkout.",
+    "firstSteps": [
+      "Run `pnpm install && pnpm build` — tsc runs noEmit; zero errors means the scaffold is wired correctly.",
+      "Run `node validate-pci-pack.mjs` — prints 'pci-pack ok' when all required files and exports are present.",
+      "Wire `redactPanInObject()` from `src/pan-redact.ts` onto every log sink and error tracer before the SDK captures request bodies.",
+      "Use `assertNoChdInRef()` from `src/tokenize.ts` in every code path that accepts a payment reference object.",
+      "Import everything through `src/index.ts` — the barrel re-exports the full public surface."
+    ],
+    "gotchas": [
+      "CVV must NEVER be stored post-authorization — PCI DSS 3.2.1 prohibits it even in encrypted form.",
+      "PAN in URL query strings is a violation — always POST to payment endpoints.",
+      "Test card numbers in fixtures (e.g. 4242…) still count as CHD in scope assessments. Quarantine test data.",
+      "Stripe restricted key: scope it to PaymentIntents only for server-side code; never ship the full secret key.",
+      "DO NOT log request/response bodies on payment endpoints without `redactPanInObject()` — log sinks ingest them unfiltered."
+    ],
+    "architectureNotes": [
+      "Scope-reduction strategy: Stripe Elements handles the PAN client-side; the server only ever sees `pm_…` tokens.",
+      "CHD audit events must go to a separate log store from the general app audit log — commingling expands PCI scope.",
+      "The Luhn check in `redactPan()` prevents over-redacting random numeric IDs while still catching real PANs."
+    ],
+    "placeholders": [
+      {
+        "path": "src/pan-redact.ts",
+        "description": "PAN-redaction regex. Extend PAN_PATTERN for BINs your processor uses outside the standard Luhn range."
+      }
+    ]
+  },
+  "contextHints": {
+    "commands": ["pnpm install", "pnpm build", "node validate-pci-pack.mjs"],
+    "entrypoints": ["src/index.ts", "src/pan-redact.ts", "src/tokenize.ts"],
+    "preview": null,
+    "extensionPoints": ["src/pan-redact.ts", "src/tokenize.ts"]
+  }
+}

package/registry/layers/framework/phaser-game/files/src/main.ts

@@ -0,0 +1,19 @@
+import Phaser from 'phaser'
+import { MainScene } from './scenes/MainScene.js'
+
+new Phaser.Game({
+  type: Phaser.AUTO,
+  parent: 'game',
+  width: 960,
+  height: 540,
+  backgroundColor: '#0b0d10',
+  physics: {
+    default: 'arcade',
+    arcade: { gravity: { x: 0, y: 400 }, debug: false },
+  },
+  scale: {
+    mode: Phaser.Scale.FIT,
+    autoCenter: Phaser.Scale.CENTER_BOTH,
+  },
+  scene: [MainScene],
+})

package/registry/layers/framework/phaser-game/files/src/scenes/MainScene.ts

@@ -0,0 +1,38 @@
+import Phaser from 'phaser'
+
+export class MainScene extends Phaser.Scene {
+  private sprite?: Phaser.Physics.Arcade.Sprite
+  private cursors?: Phaser.Types.Input.Keyboard.CursorKeys
+
+  constructor() {
+    super({ key: 'MainScene' })
+  }
+
+  preload(): void {
+    const g = this.make.graphics({ x: 0, y: 0 }, false)
+    g.fillStyle(0x6ea8ff, 1)
+    g.fillCircle(24, 24, 24)
+    g.generateTexture('ball', 48, 48)
+    g.destroy()
+  }
+
+  create(): void {
+    this.add.text(24, 24, 'Starter Foundry — Phaser', { color: '#d5deeb', fontSize: '18px' })
+
+    const ball = this.physics.add.sprite(480, 120, 'ball')
+    ball.setBounce(0.85)
+    ball.setCollideWorldBounds(true)
+    ball.setVelocity(Phaser.Math.Between(-180, 180), 60)
+    this.sprite = ball
+
+    this.cursors = this.input.keyboard?.createCursorKeys()
+  }
+
+  update(_time: number, delta: number): void {
+    if (!this.sprite || !this.cursors) return
+    const impulse = (delta / 1000) * 900
+    if (this.cursors.left?.isDown) this.sprite.setVelocityX(this.sprite.body!.velocity.x - impulse)
+    if (this.cursors.right?.isDown) this.sprite.setVelocityX(this.sprite.body!.velocity.x + impulse)
+    if (this.cursors.up?.isDown && (this.sprite.body as Phaser.Physics.Arcade.Body).blocked.down) this.sprite.setVelocityY(-400)
+  }
+}

package/registry/layers/framework/phaser-game/manifest.json

@@ -0,0 +1,55 @@
+{
+  "id": "phaser-game",
+  "description": "Phaser 3 framework layer — Phaser.Game bootstrap + a single MainScene with arcade physics, a bouncing sprite, and cursor-key input wired from first render.",
+  "appliesTo": ["phaser-game"],
+  "files": [
+    { "source": "files/src/main.ts", "target": "src/main.ts" },
+    { "source": "files/src/scenes/MainScene.ts", "target": "src/scenes/MainScene.ts" }
+  ],
+  "packageDeps": {
+    "dependencies": {
+      "phaser": "^3.87.0"
+    },
+    "devDependencies": {
+      "typescript": "^5.9.0",
+      "vite": "^6.4.2"
+    }
+  },
+  "buildHints": {
+    "whenToUse": "2D browser games — platformers, arcade, tower defense, match-3, tile-based roguelikes. Pick this over three.js when the primary surface is a 2D canvas with sprites + physics, not 3D geometry.",
+    "firstSteps": [
+      "Run `pnpm install` then `pnpm dev` — Vite serves on 5173 with HMR; the bouncing ball renders immediately.",
+      "Add new scenes under `src/scenes/` and register them in the `scene` array of the Phaser.Game config in `src/main.ts`.",
+      "Put art assets in `public/assets/` and load them with `this.load.image('key', 'assets/foo.png')` inside a Scene's `preload()`.",
+      "Arcade physics is enabled by default — attach a physics body via `this.physics.add.sprite(x, y, key)`.",
+      "Run `pnpm build` to emit static assets to `dist/` — deploy to any static host."
+    ],
+    "gotchas": [
+      "`this` inside `preload/create/update` is the Scene, not the Game. If you extract callbacks, bind or use arrow functions — losing `this` silently breaks asset loading.",
+      "Phaser clamps `update(time, delta)` delta — never assume 1/60 s between frames on throttled tabs. Always scale movement by `delta / 1000`.",
+      "Sprite textures are cached by key — loading the same key twice is a no-op after the first load. Use distinct keys per asset or call `this.textures.remove(key)` before reloading.",
+      "Canvas size is controlled by the Phaser.Game config `scale` property, NOT CSS. Setting CSS width/height stretches the canvas and breaks pointer coordinates.",
+      "Phaser ships its own TypeScript declarations; no `@types/phaser` package is needed or available."
+    ],
+    "architectureNotes": [
+      "One Phaser.Game instance per page. Scenes are the unit of composition — add, switch, pause, resume via `this.scene.*`.",
+      "Keep game state in the Scene (or a Scene's `registry`); do NOT attach it to `window`/global. Scene transitions clear local state."
+    ],
+    "placeholders": [
+      {
+        "path": "src/scenes/MainScene.ts",
+        "description": "Default scene with a bouncing sprite + cursor-key input. Replace the graphics-generated ball + logic with your actual game loop; keep the scene lifecycle hooks (preload/create/update)."
+      },
+      {
+        "path": "src/main.ts",
+        "description": "Phaser.Game config with arcade physics and FIT scaling. Adjust width/height, gravity, and the scene array as the game grows."
+      }
+    ]
+  },
+  "contextHints": {
+    "commands": ["pnpm install", "pnpm dev", "pnpm build", "pnpm validate"],
+    "entrypoints": ["src/main.ts", "src/scenes/MainScene.ts"],
+    "preview": { "path": "/" },
+    "extensionPoints": ["src/main.ts", "src/scenes", "public/assets"]
+  }
+}

package/registry/layers/framework/pixijs-game/files/src/main.ts

@@ -0,0 +1,49 @@
+import { Application, Graphics, Text } from 'pixi.js'
+
+const canvas = document.getElementById('stage') as HTMLCanvasElement
+if (!canvas) throw new Error('#stage canvas missing from index.html')
+
+const app = new Application()
+
+await app.init({
+  canvas,
+  width: window.innerWidth,
+  height: window.innerHeight,
+  background: '#0b0d10',
+  antialias: true,
+  autoDensity: true,
+  resolution: Math.min(window.devicePixelRatio, 2),
+  preference: 'webgpu',
+})
+
+const title = new Text({
+  text: 'Starter Foundry — Pixi v8',
+  style: { fill: '#d5deeb', fontSize: 18, fontFamily: 'system-ui' },
+})
+title.x = 24
+title.y = 24
+app.stage.addChild(title)
+
+const badge = new Graphics()
+  .roundRect(-60, -60, 120, 120, 16)
+  .fill({ color: 0x6ea8ff, alpha: 0.85 })
+  .stroke({ color: 0xffffff, width: 2, alpha: 0.2 })
+badge.position.set(app.screen.width / 2, app.screen.height / 2)
+app.stage.addChild(badge)
+
+app.ticker.add((tick) => {
+  badge.rotation += 0.01 * tick.deltaTime
+})
+
+function onResize(): void {
+  app.renderer.resize(window.innerWidth, window.innerHeight)
+  badge.position.set(app.screen.width / 2, app.screen.height / 2)
+}
+window.addEventListener('resize', onResize)
+
+if (import.meta.hot) {
+  import.meta.hot.dispose(() => {
+    window.removeEventListener('resize', onResize)
+    app.destroy(true, { children: true, texture: true, textureSource: true })
+  })
+}

package/registry/layers/framework/pixijs-game/files/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/registry/layers/framework/pixijs-game/manifest.json

@@ -0,0 +1,51 @@
+{
+  "id": "pixijs-game",
+  "description": "Pixi.js v8 framework layer — async Application init, rotating gradient badge, resize + HMR dispose wired from first render.",
+  "appliesTo": ["pixijs-game"],
+  "files": [
+    { "source": "files/src/main.ts", "target": "src/main.ts" },
+    { "source": "files/src/vite-env.d.ts", "target": "src/vite-env.d.ts" }
+  ],
+  "packageDeps": {
+    "dependencies": {
+      "pixi.js": "^8.5.2"
+    },
+    "devDependencies": {
+      "typescript": "^5.9.0",
+      "vite": "^6.4.2"
+    }
+  },
+  "buildHints": {
+    "whenToUse": "High-performance 2D canvas work — interactive data viz, particle systems, generative art, map editors, live charts. Pick over Phaser when you want a raw renderer without scene+physics machinery.",
+    "firstSteps": [
+      "Run `pnpm install` then `pnpm dev` — Vite serves on 5173 with HMR; a rotating gradient badge renders immediately.",
+      "Pixi v8 uses `await app.init(...)` — it is ASYNC. Do not call `new Application()` and start rendering synchronously; sprites attached before init never appear.",
+      "Put art in `public/assets/` and load via `Assets.load('assets/foo.png')` — the v8 Assets loader replaces the v7 Loader class.",
+      "Attach children to `app.stage` (or a sub-Container). `app.ticker.add(...)` drives per-frame updates.",
+      "Run `pnpm build` to emit static assets to `dist/` — deploy on any static host."
+    ],
+    "gotchas": [
+      "Pixi v8 is a BREAKING rewrite of v7. Do NOT copy v7 tutorials — `new Application({ width, height })` is gone; use `const app = new Application(); await app.init({ width, height });`.",
+      "Pixi v8 supports both WebGL and WebGPU. Default renderer is chosen automatically — pin with `preference: 'webgpu'` if needed.",
+      "The Ticker runs after `app.init()` only. Don't add ticker callbacks before init — they're attached to a placeholder and never fire.",
+      "On teardown (HMR, route change), call `app.destroy(true, { children: true, texture: true, textureSource: true })` to release GPU memory. Without it, HMR leaks textures fast. (`textureSource: true` disposes the v8 TextureSource backing — always include it.)",
+      "`import.meta.hot` requires Vite client types — `src/vite-env.d.ts` provides the reference directive; do not delete it or typecheck will fail on the HMR block."
+    ],
+    "architectureNotes": [
+      "Application owns: renderer, stage (root Container), ticker. One Application per canvas.",
+      "Scene composition = Container hierarchy. Containers transform children; leaves are Sprites, Graphics, Text, Mesh."
+    ],
+    "placeholders": [
+      {
+        "path": "src/main.ts",
+        "description": "Application init + rotating badge. Replace the badge Graphics with actual sprites or draw calls; keep the init, resize, and HMR dispose plumbing."
+      }
+    ]
+  },
+  "contextHints": {
+    "commands": ["pnpm install", "pnpm dev", "pnpm build"],
+    "entrypoints": ["src/main.ts"],
+    "preview": { "path": "/" },
+    "extensionPoints": ["src/main.ts", "src/scenes", "public/assets"]
+  }
+}

package/registry/layers/framework/polymarket-portfolio-hedging/manifest.json

@@ -0,0 +1,8 @@
+{
+  "id": "polymarket-portfolio-hedging",
+  "description": "node framework layer for polymarket-portfolio-hedging.",
+  "appliesTo": [
+    "polymarket-portfolio-hedging"
+  ],
+  "files": []
+}

package/registry/layers/framework/rag-pipeline-py/files/AGENTS.md

@@ -0,0 +1,55 @@
+# RAG Pipeline — Agent Guide
+
+## What this project does
+End-to-end retrieval-augmented generation: ingest local docs → chunk → embed → Chroma → retrieve top-k → grounded LLM answer.
+
+## Install
+```bash
+pip install -e .
+cp .env.example .env   # configure LLM_BASE_URL, LLM_MODEL, EMBEDDING_MODEL, VECTOR_DB_DIR
+```
+
+## Key commands
+| Command | What it does |
+|---------|-------------|
+| `python -m src.pipeline index` | Ingest `docs/` into Chroma (rebuilds collection from scratch) |
+| `python -m src.pipeline ask "<question>"` | Retrieve top-k chunks and synthesize a grounded answer |
+
+## Environment variables (`.env`)
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `LLM_BASE_URL` | `http://localhost:11434` | Ollama or any OpenAI-compatible server |
+| `LLM_MODEL` | `llama3.1:8b` | Model name passed to the LLM |
+| `EMBEDDING_MODEL` | `sentence-transformers/all-MiniLM-L6-v2` | Local embedding model |
+| `VECTOR_DB_DIR` | `./chroma_db` | On-disk Chroma persistence directory |
+| `COLLECTION_NAME` | `rag-docs` | Chroma collection name |
+| `DOCS_DIR` | `./docs` | Source corpus root |
+| `CHUNK_SIZE` | `800` | Character chunk size |
+| `CHUNK_OVERLAP` | `120` | Character overlap between chunks |
+| `TOP_K` | `4` | Chunks retrieved per query |
+
+## Architecture
+```
+docs/ ──► _load_docs() ──► _chunk() ──► SentenceTransformer.encode() ──► chromadb
+                                                                               │
+query ─────────────────────────────────────────────────────────────► retrieve (top-k)
+                                                                               │
+                                                                          _llm_chat()
+                                                                               │
+                                                                           answer
+```
+
+## Entry point
+`src/pipeline.py` — single file, all logic: `index()`, `retrieve()`, `ask()`, `main()`.
+
+## Extending
+- **Add docs**: drop `.md`, `.txt`, or `.pdf` files into `docs/` and re-run `index`.
+- **Change LLM**: set `LLM_BASE_URL` + `LLM_MODEL` in `.env` — any OpenAI-compatible endpoint works.
+- **Change embeddings**: update `EMBEDDING_MODEL`, delete `VECTOR_DB_DIR`, re-run `index`.
+- **Expose as API**: import `ask()` into a FastAPI route — `pip install fastapi uvicorn`.
+- **PDF support**: `pip install pypdf` (or `pip install -e .[pdf]`).
+
+## Gotchas
+- Mixing embeddings from different models in the same Chroma collection returns garbage — always delete `VECTOR_DB_DIR` when changing `EMBEDDING_MODEL`.
+- Ollama must be running before `ask` — `ollama serve`, then `ollama pull llama3.1:8b`.
+- The Chroma collection is rebuilt from scratch on every `index` run — this is intentional to avoid stale chunks.

package/registry/layers/framework/rag-pipeline-py/files/__init__.py

@@ -0,0 +1 @@
+"""Local RAG pipeline — see src/pipeline.py."""