Spaces:

openenv-community
/

optigami

Running

App Files Files Community

go-back

by ianalin123 - opened 3 days ago

base: refs/heads/main

←

from: refs/pr/6

Discussion Files changed

+30363

-4159

This view is limited to 50 files because it contains too many changes. See the raw diff here.

Files changed (50) hide show

.dockerignore +18 -0
.gitignore +2 -3
Dockerfile +27 -0
README.md +21 -67
build/asset-manifest.json +13 -0
build/favicon.ico +0 -0
build/index.html +1 -0
build/logo192.png +0 -0
build/logo512.png +0 -0
build/manifest.json +25 -0
build/robots.txt +3 -0
build/static/css/main.2ef3bb14.css +2 -0
build/static/css/main.2ef3bb14.css.map +1 -0
build/static/js/main.b94094b6.js +0 -0
build/static/js/main.b94094b6.js.LICENSE.txt +49 -0
build/static/js/main.b94094b6.js.map +0 -0
docs/optigami_handoff.md +767 -0
engine/fold_engine.py +0 -207
engine/materials.py +0 -79
engine/metrics.py +0 -104
engine/paper.py +0 -488
engine/physics.py +0 -257
engine/validation.py +0 -256
{engine → env}/__init__.py +0 -0
env/environment.py +260 -0
env/graph.py +117 -0
env/paper_state.py +164 -0
env/prompts.py +284 -0
env/rewards.py +135 -0
{planner → env/targets}/__init__.py +0 -0
env/targets/accordion_3h.fold +67 -0
env/targets/accordion_4h.fold +79 -0
env/targets/diagonal_anti.fold +35 -0
env/targets/diagonal_main.fold +35 -0
env/targets/half_horizontal.fold +43 -0
env/targets/half_vertical.fold +43 -0
env/targets/thirds_h.fold +55 -0
env/targets/thirds_v.fold +55 -0
env/targets/validator.py +119 -0
env/targets/validator_check.py +21 -0
env/verifier.py +261 -0
openenv.yaml +6 -0
openenv_runtime/__init__.py +11 -0
openenv_runtime/environment.py +53 -0
openenv_runtime/models.py +53 -0
openenv_server/__init__.py +1 -0
openenv_server/app.py +269 -0
package-lock.json +0 -0
package.json +1 -0
planner/decomposer.py +0 -284

.dockerignore ADDED Viewed

	@@ -0,0 +1,18 @@

+.git
+.DS_Store
+__pycache__
+*.pyc
+*.pyo
+.pytest_cache
+.claude
+node_modules
+build
+research
+docs
+plans
+RESEARCH_NOTES.md
+trainer
+train.py
+sim
+viz
+planner

.gitignore CHANGED Viewed

@@ -8,9 +8,6 @@
 # testing
 /coverage
-# production
-/build
 # misc
 .DS_Store
 .env.local
@@ -28,3 +25,5 @@ __pycache__/
 # Reference repos (not pushed to HF)
 .reference/

 # testing
 /coverage
 # misc
 .DS_Store
 .env.local
 # Reference repos (not pushed to HF)
 .reference/
+*.pyc
+__pycache__/

Dockerfile ADDED Viewed

	@@ -0,0 +1,27 @@

+FROM node:20-alpine AS web-builder
+WORKDIR /web
+COPY package*.json ./
+RUN npm ci --no-audit --no-fund
+COPY public ./public
+COPY src ./src
+RUN npm run build
+FROM ghcr.io/meta-pytorch/openenv-base:latest
+WORKDIR /app
+# Install Python deps first for better layer caching
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt \
+    && pip install --no-cache-dir "openenv-core[core]>=0.2.1"
+# Copy application source
+COPY . /app
+# Overlay the compiled React frontend
+COPY --from=web-builder /web/build /app/build
+EXPOSE 8000
+CMD ["uvicorn", "openenv_server.app:app", "--host", "0.0.0.0", "--port", "8000"]

README.md CHANGED Viewed

@@ -3,81 +3,35 @@ title: Optigami
 emoji: 🐠
 colorFrom: indigo
 colorTo: red
-sdk: static
 pinned: false
-app_build_command: npm run build
-app_file: build/index.html
 license: mit
-short_description: ':)'
 ---
-# Getting Started with Create React App
-This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).
-## Available Scripts
-In the project directory, you can run:
-### `npm start`
-Runs the app in the development mode.\
-Open [http://localhost:3000](http://localhost:3000) to view it in your browser.
-The page will reload when you make changes.\
-You may also see any lint errors in the console.
-### `npm test`
-Launches the test runner in the interactive watch mode.\
-See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.
-### `npm run build`
-Builds the app for production to the `build` folder.\
-It correctly bundles React in production mode and optimizes the build for the best performance.
-The build is minified and the filenames include the hashes.\
-Your app is ready to be deployed!
-See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.
-### `npm run eject`
-**Note: this is a one-way operation. Once you `eject`, you can't go back!**
-If you aren't satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project.
-Instead, it will copy all the configuration files and the transitive dependencies (webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you're on your own.
-You don't have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn't feel obligated to use this feature. However we understand that this tool wouldn't be useful if you couldn't customize it when you are ready for it.
-## Learn More
-You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started).
-To learn React, check out the [React documentation](https://reactjs.org/).
-### Code Splitting
-This section has moved here: [https://facebook.github.io/create-react-app/docs/code-splitting](https://facebook.github.io/create-react-app/docs/code-splitting)
-### Analyzing the Bundle Size
-This section has moved here: [https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size](https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size)
-### Making a Progressive Web App
-This section has moved here: [https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app](https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app)
-### Advanced Configuration
-This section has moved here: [https://facebook.github.io/create-react-app/docs/advanced-configuration](https://facebook.github.io/create-react-app/docs/advanced-configuration)
-### Deployment
-This section has moved here: [https://facebook.github.io/create-react-app/docs/deployment](https://facebook.github.io/create-react-app/docs/deployment)
-### `npm run build` fails to minify
-This section has moved here: [https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify](https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify)

 emoji: 🐠
 colorFrom: indigo
 colorTo: red
+sdk: docker
 pinned: false
+app_port: 8000
 license: mit
+short_description: OpenEnv origami environment and demo
 ---
+# Optigami
+OpenEnv-compatible origami RL environment with:
+- environment + reward checks in `env/`
+- OpenEnv server adapter in `openenv_runtime/` and `openenv_server/`
+- Dockerized deployment for Hugging Face Spaces
+Entry point: `openenv_server.app:app`
+Manifest: `openenv.yaml`
+Container: `Dockerfile`
+## Local Run
+```bash
+uvicorn openenv_server.app:app --host 0.0.0.0 --port 8000
+```
+## Frontend (optional local React demo)
+```bash
+npm install
+npm start
+```
+This serves the dashboard against the FastAPI API.

build/asset-manifest.json ADDED Viewed

	@@ -0,0 +1,13 @@

+{
+  "files": {
+    "main.css": "/static/css/main.2ef3bb14.css",
+    "main.js": "/static/js/main.b94094b6.js",
+    "index.html": "/index.html",
+    "main.2ef3bb14.css.map": "/static/css/main.2ef3bb14.css.map",
+    "main.b94094b6.js.map": "/static/js/main.b94094b6.js.map"
+  },
+  "entrypoints": [
+    "static/css/main.2ef3bb14.css",
+    "static/js/main.b94094b6.js"
+  ]
+}

build/favicon.ico ADDED Viewed

build/index.html ADDED Viewed

	@@ -0,0 +1 @@

+ <!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="/favicon.ico"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="Web site created using create-react-app"/><link rel="apple-touch-icon" href="/logo192.png"/><link rel="manifest" href="/manifest.json"/><title>React App</title><script defer="defer" src="/static/js/main.b94094b6.js"></script><link href="/static/css/main.2ef3bb14.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>

build/logo192.png ADDED Viewed

build/logo512.png ADDED Viewed

build/manifest.json ADDED Viewed

	@@ -0,0 +1,25 @@

+{
+  "short_name": "React App",
+  "name": "Create React App Sample",
+  "icons": [
+    {
+      "src": "favicon.ico",
+      "sizes": "64x64 32x32 24x24 16x16",
+      "type": "image/x-icon"
+    },
+    {
+      "src": "logo192.png",
+      "type": "image/png",
+      "sizes": "192x192"
+    },
+    {
+      "src": "logo512.png",
+      "type": "image/png",
+      "sizes": "512x512"
+    }
+  ],
+  "start_url": ".",
+  "display": "standalone",
+  "theme_color": "#000000",
+  "background_color": "#ffffff"
+}

build/robots.txt ADDED Viewed

	@@ -0,0 +1,3 @@

+# https://www.robotstxt.org/robotstxt.html
+User-agent: *
+Disallow:

build/static/css/main.2ef3bb14.css ADDED Viewed

	@@ -0,0 +1,2 @@


1	+ @import url(https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;500;700&family=IBM+Plex+Mono:wght@300;400;500&display=swap);*,:after,:before{box-sizing:border-box;margin:0;padding:0}body{-webkit-font-smoothing:antialiased;background:#0d0d14;color:#f8fafc;font-family:IBM Plex Mono,monospace;font-size:13px;line-height:1.5;overflow-x:hidden}::-webkit-scrollbar{height:4px;width:4px}::-webkit-scrollbar-track{background:#0d0d14}::-webkit-scrollbar-thumb{background:#2a2a3a}::-webkit-scrollbar-thumb:hover{background:#3a3a5a}:root{--bg:#0d0d14;--surface:#13131d;--surface-2:#1a1a2e;--paper-white:#fafaf5;--paper-edge:#2a2a3a;--mountain:#f59e0b;--valley:#38bdf8;--target-ghost:#7c3aed33;--target-ghost-stroke:#7c3aed73;--validity:#22d3ee;--progress:#22c55e;--economy:#a78bfa;--text-primary:#f8fafc;--text-dim:#64748b;--border:#2a2a3a;--border-bright:#3a3a5a;--font-display:"JetBrains Mono",monospace;--font-mono:"IBM Plex Mono",monospace}.app{background:#0d0d14;background:var(--bg);display:flex;flex-direction:column;height:100vh;overflow:hidden}.app-header{align-items:center;background:#13131d;background:var(--surface);border-bottom:1px solid #2a2a3a;border-bottom:1px solid var(--border);display:flex;flex-shrink:0;gap:24px;height:48px;padding:0 20px;z-index:10}.app-title{color:#f8fafc;color:var(--text-primary);font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:14px;font-weight:700;letter-spacing:.12em;white-space:nowrap}.app-title .title-accent{color:#f59e0b;color:var(--mountain)}.header-sep{background:#2a2a3a;background:var(--border);flex-shrink:0;height:24px;width:1px}.header-right{align-items:center;display:flex;gap:16px;margin-left:auto}.replay-badge{background:#38bdf81a;border:1px solid #38bdf84d;border-radius:3px;color:#38bdf8;letter-spacing:.1em;padding:3px 8px}.back-to-grid-btn,.replay-badge{font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:10px}.back-to-grid-btn{background:#0000;border:1px solid #1e2a3a;border-radius:3px;color:#64748b;cursor:pointer;letter-spacing:.08em;padding:3px 10px}.back-to-grid-btn:hover{border-color:#64748b;color:#e2e8f0}.api-status{align-items:center;display:flex;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:11px;gap:6px;letter-spacing:.08em}.api-status-dot{background:#64748b;background:var(--text-dim);border-radius:50%;height:6px;width:6px}.api-status-dot.ok{background:#22c55e;background:var(--progress);box-shadow:0 0 6px #22c55e;box-shadow:0 0 6px var(--progress)}.api-status-dot.err{background:#ef4444;box-shadow:0 0 6px #ef4444}.app-body{display:grid;flex:1 1;grid-template-columns:1fr 280px;overflow:hidden}.app-left{border-right:1px solid #2a2a3a;border-right:1px solid var(--border)}.app-left,.app-right{display:flex;flex-direction:column;overflow:hidden}.app-right{background:#13131d;background:var(--surface)}.canvas-row{border-bottom:1px solid #2a2a3a;border-bottom:1px solid var(--border);display:flex;flex-shrink:0;gap:0;overflow-x:auto;padding:16px}.canvas-wrap{display:flex;flex:1 1;flex-direction:column;gap:8px;min-width:280px}.canvas-wrap+.canvas-wrap{margin-left:16px}.canvas-label{color:#64748b;color:var(--text-dim);font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:10px;font-weight:500;letter-spacing:.14em;text-transform:uppercase}.canvas-svg{background:#fafaf5;background:var(--paper-white);display:block}.canvas-3d{background:linear-gradient(180deg,#1a1a2e,#0f101a);border:1px solid #2a2a3a;border:1px solid var(--border);display:block}.canvas-label-row{align-items:center;display:flex;gap:10px;justify-content:space-between}.fold-mode-toggle{background:#13131d;background:var(--surface);border:1px solid #2a2a3a;border:1px solid var(--border);display:inline-flex}.fold-mode-btn{background:#0000;border:none;color:#64748b;color:var(--text-dim);cursor:pointer;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:9px;letter-spacing:.08em;padding:3px 7px}.fold-mode-btn+.fold-mode-btn{border-left:1px solid #2a2a3a;border-left:1px solid var(--border)}.fold-mode-btn.active{background:#1f2538;color:#f8fafc;color:var(--text-primary)}.step-feed-section{display:flex;flex:1 1;flex-direction:column;overflow:hidden}.section-header{border-bottom:1px solid #2a2a3a;border-bottom:1px solid var(--border);color:#64748b;color:var(--text-dim);flex-shrink:0;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:10px;font-weight:500;letter-spacing:.14em;padding:8px 16px;text-transform:uppercase}.step-feed{flex:1 1;overflow-y:auto;padding:4px 0}.step-entry{border-bottom:1px solid #2a2a3a;border-bottom:1px solid var(--border);cursor:default;display:flex;flex-direction:column;gap:2px;padding:8px 16px;transition:background .1s}.step-entry:hover{background:#13131d;background:var(--surface)}.step-entry.active{background:#1a1a2e;background:var(--surface-2);border-left:2px solid #38bdf8;border-left:2px solid var(--valley);padding-left:14px}.step-entry-top{align-items:center;display:flex;gap:8px}.step-num{color:#64748b;color:var(--text-dim);flex-shrink:0;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:10px;font-weight:700;width:24px}.step-instruction{color:#f8fafc;color:var(--text-primary);flex:1 1;font-size:12px}.assign-badge{flex-shrink:0;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:10px;font-weight:700;line-height:1.4;padding:1px 5px}.assign-badge.M{background:#f59e0b;background:var(--mountain);color:#0d0d14}.assign-badge.V{background:#38bdf8;background:var(--valley);color:#0d0d14}.assign-badge.B{background:#3a3a5a;background:var(--border-bright)}.assign-badge.B,.step-reward-delta{color:#64748b;color:var(--text-dim)}.step-reward-delta{font-size:11px;padding-left:32px}.step-reward-delta .delta-positive{color:#22c55e;color:var(--progress)}.step-reward-delta .delta-negative{color:#ef4444}.reward-panel{border-bottom:1px solid #2a2a3a;border-bottom:1px solid var(--border);flex-shrink:0;padding:12px 16px}.reward-row{align-items:center;display:flex;gap:8px;margin-bottom:6px}.reward-row:last-child{margin-bottom:0}.reward-label{color:#64748b;color:var(--text-dim);flex-shrink:0;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:10px;font-weight:500;letter-spacing:.06em;text-transform:uppercase;width:72px}.reward-track{background:#0d0d14;background:var(--bg);border:1px solid #2a2a3a;border:1px solid var(--border);flex:1 1;height:8px;overflow:hidden}.reward-bar{height:100%;transition:width .4s ease}.reward-value{color:#f8fafc;color:var(--text-primary);flex-shrink:0;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:11px;font-weight:500;text-align:right;width:36px}.reward-value.dim{color:#64748b;color:var(--text-dim)}.reward-divider{background:#2a2a3a;background:var(--border);height:1px;margin:6px 0}.info-badges{display:flex;flex-direction:column;gap:8px;padding:12px 16px}.info-row{align-items:center;display:flex;gap:8px;justify-content:space-between}.info-key{color:#64748b;color:var(--text-dim);font-size:10px;font-weight:500;letter-spacing:.06em;text-transform:uppercase}.info-key,.info-val{font-family:JetBrains Mono,monospace;font-family:var(--font-display)}.info-val{color:#f8fafc;color:var(--text-primary);font-size:11px;font-weight:700}.info-val.bool-true{color:#22c55e;color:var(--progress)}.info-val.bool-false{color:#ef4444}.info-val.dim{color:#64748b;color:var(--text-dim)}.target-selector{align-items:center;display:flex;gap:8px}.target-selector-label{color:#64748b;color:var(--text-dim);font-size:10px;font-weight:500;letter-spacing:.1em;text-transform:uppercase;white-space:nowrap}.target-select,.target-selector-label{font-family:JetBrains Mono,monospace;font-family:var(--font-display)}.target-select{background:#1a1a2e;background:var(--surface-2);border:1px solid #3a3a5a;border:1px solid var(--border-bright);color:#f8fafc;color:var(--text-primary);cursor:pointer;font-size:11px;min-width:180px;outline:none;padding:4px 8px}.target-select:focus{border-color:#38bdf8;border-color:var(--valley)}optgroup{background:#13131d;background:var(--surface);color:#64748b;color:var(--text-dim);font-size:10px}optgroup,option{font-family:JetBrains Mono,monospace;font-family:var(--font-display)}option{background:#1a1a2e;background:var(--surface-2);color:#f8fafc;color:var(--text-primary)}.player-controls{align-items:center;display:flex;flex-shrink:0;gap:6px}.ctrl-btn{background:#1a1a2e;background:var(--surface-2);border:1px solid #3a3a5a;border:1px solid var(--border-bright);color:#f8fafc;color:var(--text-primary);cursor:pointer;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:11px;font-weight:500;letter-spacing:.04em;line-height:1.4;padding:4px 10px;transition:background .1s,border-color .1s;white-space:nowrap}.ctrl-btn:hover:not(:disabled){background:#13131d;background:var(--surface);border-color:#64748b;border-color:var(--text-dim)}.ctrl-btn:disabled{cursor:not-allowed;opacity:.35}.ctrl-btn.play{border-color:#38bdf8;border-color:var(--valley);color:#38bdf8;color:var(--valley)}.ctrl-btn.play:hover:not(:disabled){background:#38bdf81a}.ctrl-step-display{border:1px solid #2a2a3a;border:1px solid var(--border);color:#64748b;color:var(--text-dim);font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:11px;min-width:72px;padding:4px 8px;text-align:center;white-space:nowrap}.app-overlay,.ctrl-step-display{background:#0d0d14;background:var(--bg)}.app-overlay{inset:0;justify-content:center;position:fixed;z-index:100}.app-overlay,.overlay-message{align-items:center;display:flex}.overlay-message{color:#64748b;color:var(--text-dim);font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:13px;gap:12px;letter-spacing:.1em}.pulse-dot{animation:pulse 1.2s ease-in-out infinite;background:#38bdf8;background:var(--valley);border-radius:50%;height:8px;width:8px}@keyframes pulse{0%,to{opacity:.2;transform:scale(.8)}50%{opacity:1;transform:scale(1)}}.episode-loading{align-items:center;color:#64748b;color:var(--text-dim);display:flex;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:11px;gap:8px;justify-content:center;letter-spacing:.08em;padding:12px 16px}
2	+ /# sourceMappingURL=main.2ef3bb14.css.map/

build/static/css/main.2ef3bb14.css.map ADDED Viewed

	@@ -0,0 +1 @@

+ {"version":3,"file":"static/css/main.2ef3bb14.css","mappings":"6IAEA,iBACE,qBAAsB,CACtB,QAAS,CACT,SACF,CAEA,KAME,kCAAmC,CALnC,kBAAmB,CACnB,aAAc,CACd,mCAAuC,CACvC,cAAe,CACf,eAAgB,CAEhB,iBACF,CAEA,oBAEE,UAAW,CADX,SAEF,CAEA,0BACE,kBACF,CAEA,0BACE,kBACF,CAEA,gCACE,kBACF,CCjCA,MACE,YAAa,CACb,iBAAkB,CAClB,mBAAoB,CACpB,qBAAsB,CACtB,oBAAqB,CACrB,kBAAmB,CACnB,gBAAiB,CACjB,wBAAwC,CACxC,+BAA+C,CAC/C,kBAAmB,CACnB,kBAAmB,CACnB,iBAAkB,CAClB,sBAAuB,CACvB,kBAAmB,CACnB,gBAAiB,CACjB,uBAAwB,CACxB,yCAA2C,CAC3C,qCACF,CAEA,KAIE,kBAAqB,CAArB,oBAAqB,CAHrB,YAAa,CACb,qBAAsB,CACtB,YAAa,CAEb,eACF,CAGA,YAEE,kBAAmB,CAKnB,kBAA0B,CAA1B,yBAA0B,CAD1B,+BAAsC,CAAtC,qCAAsC,CALtC,YAAa,CAOb,aAAc,CALd,QAAS,CAET,WAAY,CADZ,cAAe,CAKf,UACF,CAEA,WAKE,aAA0B,CAA1B,yBAA0B,CAJ1B,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAChB,oBAAsB,CAEtB,kBACF,CAEA,yBACE,aAAsB,CAAtB,qBACF,CAEA,YAGE,kBAAyB,CAAzB,wBAAyB,CACzB,aAAc,CAFd,WAAY,CADZ,SAIF,CAEA,cAEE,kBAAmB,CADnB,YAAa,CAEb,QAAS,CACT,gBACF,CAEA,cAKE,oBAAmC,CACnC,0BAAyC,CAEzC,iBAAkB,CAJlB,aAAc,CADd,mBAAqB,CAIrB,eAEF,CAEA,gCATE,oCAAgC,CAAhC,+BAAgC,CADhC,cAoBF,CAVA,kBAKE,gBAAuB,CACvB,wBAAyB,CAEzB,iBAAkB,CAJlB,aAAc,CAKd,cAAe,CANf,oBAAsB,CAItB,gBAGF,CACA,wBAA0C,oBAAqB,CAArC,aAAuC,CAEjE,YAKE,kBAAmB,CADnB,YAAa,CAFb,oCAAgC,CAAhC,+BAAgC,CADhC,cAAe,CAKf,OAAQ,CAHR,oBAIF,CAEA,gBAIE,kBAA2B,CAA3B,0BAA2B,CAD3B,iBAAkB,CADlB,UAAW,CADX,SAIF,CAEA,mBACE,kBAA2B,CAA3B,0BAA2B,CAC3B,0BAAmC,CAAnC,kCACF,CAEA,oBACE,kBAAmB,CACnB,0BACF,CAGA,UACE,YAAa,CAEb,QAAO,CADP,+BAAgC,CAEhC,eACF,CAEA,UAIE,8BAAqC,CAArC,oCACF,CAEA,qBANE,YAAa,CACb,qBAAsB,CACtB,eASF,CALA,WAIE,kBAA0B,CAA1B,yBACF,CAGA,YAKE,+BAAsC,CAAtC,qCAAsC,CAJtC,YAAa,CAGb,aAAc,CAFd,KAAM,CAIN,eAAgB,CAHhB,YAIF,CAEA,aACE,YAAa,CAGb,QAAO,CAFP,qBAAsB,CACtB,OAAQ,CAER,eACF,CAEA,0BACE,gBACF,CAEA,cAKE,aAAsB,CAAtB,qBAAsB,CAJtB,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAChB,oBAAsB,CAEtB,wBACF,CAEA,YAEE,kBAA8B,CAA9B,6BAA8B,CAD9B,aAEF,CAEA,WAEE,kDAA6D,CAC7D,wBAA+B,CAA/B,8BAA+B,CAF/B,aAGF,CAEA,kBAEE,kBAAmB,CADnB,YAAa,CAGb,QAAS,CADT,6BAEF,CAEA,kBAGE,kBAA0B,CAA1B,yBAA0B,CAD1B,wBAA+B,CAA/B,8BAA+B,CAD/B,mBAGF,CAEA,eAEE,gBAAuB,CADvB,WAAY,CAEZ,aAAsB,CAAtB,qBAAsB,CAKtB,cAAe,CAJf,oCAAgC,CAAhC,+BAAgC,CAChC,aAAc,CACd,oBAAsB,CACtB,eAEF,CAEA,8BACE,6BAAoC,CAApC,mCACF,CAEA,sBAEE,kBAAmB,CADnB,aAA0B,CAA1B,yBAEF,CAGA,mBAEE,YAAa,CADb,QAAO,CAEP,qBAAsB,CACtB,eACF,CAEA,gBAQE,+BAAsC,CAAtC,qCAAsC,CAHtC,aAAsB,CAAtB,qBAAsB,CAItB,aAAc,CARd,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAChB,oBAAsB,CAGtB,gBAAiB,CADjB,wBAIF,CAEA,WAEE,QAAO,CADP,eAAgB,CAEhB,aACF,CAEA,YAKE,+BAAsC,CAAtC,qCAAsC,CACtC,cAAe,CALf,YAAa,CACb,qBAAsB,CACtB,OAAQ,CACR,gBAAiB,CAGjB,yBACF,CAEA,kBACE,kBAA0B,CAA1B,yBACF,CAEA,mBACE,kBAA4B,CAA5B,2BAA4B,CAC5B,6BAAoC,CAApC,mCAAoC,CACpC,iBACF,CAEA,gBAEE,kBAAmB,CADnB,YAAa,CAEb,OACF,CAEA,UAIE,aAAsB,CAAtB,qBAAsB,CAEtB,aAAc,CALd,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAEhB,UAEF,CAEA,kBAEE,aAA0B,CAA1B,yBAA0B,CAC1B,QAAO,CAFP,cAGF,CAEA,cAME,aAAc,CALd,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAEhB,eAAgB,CADhB,eAGF,CAEA,gBACE,kBAA2B,CAA3B,0BAA2B,CAC3B,aACF,CAEA,gBACE,kBAAyB,CAAzB,wBAAyB,CACzB,aACF,CAEA,gBACE,kBAAgC,CAAhC,+BAEF,CAEA,mCAHE,aAAsB,CAAtB,qBAOF,CAJA,mBACE,cAAe,CAEf,iBACF,CAEA,mCACE,aAAsB,CAAtB,qBACF,CAEA,mCACE,aACF,CAGA,cAEE,+BAAsC,CAAtC,qCAAsC,CACtC,aAAc,CAFd,iBAGF,CAEA,YAEE,kBAAmB,CADnB,YAAa,CAEb,OAAQ,CACR,iBACF,CAEA,uBACE,eACF,CAEA,cAKE,aAAsB,CAAtB,qBAAsB,CAEtB,aAAc,CANd,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAChB,oBAAsB,CAItB,wBAAyB,CAFzB,UAGF,CAEA,cAGE,kBAAqB,CAArB,oBAAqB,CACrB,wBAA+B,CAA/B,8BAA+B,CAH/B,QAAO,CACP,UAAW,CAGX,eACF,CAEA,YACE,WAAY,CACZ,yBACF,CAEA,cAIE,aAA0B,CAA1B,yBAA0B,CAG1B,aAAc,CANd,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAGhB,gBAAiB,CADjB,UAGF,CAEA,kBACE,aAAsB,CAAtB,qBACF,CAEA,gBAEE,kBAAyB,CAAzB,wBAAyB,CADzB,UAAW,CAEX,YACF,CAGA,aAEE,YAAa,CACb,qBAAsB,CACtB,OAAQ,CAHR,iBAIF,CAEA,UAEE,kBAAmB,CADnB,YAAa,CAGb,OAAQ,CADR,6BAEF,CAEA,UAKE,aAAsB,CAAtB,qBAAsB,CAHtB,cAAe,CACf,eAAgB,CAChB,oBAAsB,CAEtB,wBACF,CAEA,oBARE,oCAAgC,CAAhC,+BAaF,CALA,UAIE,aAA0B,CAA1B,yBAA0B,CAF1B,cAAe,CACf,eAEF,CAEA,oBACE,aAAsB,CAAtB,qBACF,CAEA,qBACE,aACF,CAEA,cACE,aAAsB,CAAtB,qBACF,CAGA,iBAEE,kBAAmB,CADnB,YAAa,CAEb,OACF,CAEA,uBAKE,aAAsB,CAAtB,qBAAsB,CAHtB,cAAe,CACf,eAAgB,CAChB,mBAAsB,CAEtB,wBAAyB,CACzB,kBACF,CAEA,sCATE,oCAAgC,CAAhC,+BAmBF,CAVA,eACE,kBAA4B,CAA5B,2BAA4B,CAC5B,wBAAsC,CAAtC,qCAAsC,CACtC,aAA0B,CAA1B,yBAA0B,CAK1B,cAAe,CAHf,cAAe,CAIf,eAAgB,CAFhB,YAAa,CADb,eAIF,CAEA,qBACE,oBAA2B,CAA3B,0BACF,CAEA,SACE,kBAA0B,CAA1B,yBAA0B,CAC1B,aAAsB,CAAtB,qBAAsB,CAEtB,cACF,CAEA,gBAJE,oCAAgC,CAAhC,+BAQF,CAJA,OACE,kBAA4B,CAA5B,2BAA4B,CAC5B,aAA0B,CAA1B,yBAEF,CAGA,iBAEE,kBAAmB,CADnB,YAAa,CAGb,aAAc,CADd,OAEF,CAEA,UACE,kBAA4B,CAA5B,2BAA4B,CAC5B,wBAAsC,CAAtC,qCAAsC,CACtC,aAA0B,CAA1B,yBAA0B,CAK1B,cAAe,CAJf,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAKhB,oBAAsB,CADtB,eAAgB,CAHhB,gBAAiB,CAKjB,0CAA8C,CAH9C,kBAIF,CAEA,+BACE,kBAA0B,CAA1B,yBAA0B,CAC1B,oBAA6B,CAA7B,4BACF,CAEA,mBAEE,kBAAmB,CADnB,WAEF,CAEA,eACE,oBAA2B,CAA3B,0BAA2B,CAC3B,aAAoB,CAApB,mBACF,CAEA,oCACE,oBACF,CAEA,mBAKE,wBAA+B,CAA/B,8BAA+B,CAF/B,aAAsB,CAAtB,qBAAsB,CAFtB,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CAMf,cAAe,CAJf,eAAgB,CAKhB,iBAAkB,CAFlB,kBAGF,CAGA,gCAPE,kBAAqB,CAArB,oBAeF,CARA,aAEE,OAAQ,CAGR,sBAAuB,CAJvB,cAAe,CAMf,WACF,CAEA,8BANE,kBAAmB,CADnB,YAeF,CARA,iBAIE,aAAsB,CAAtB,qBAAsB,CAHtB,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CAKf,QAAS,CAJT,mBAKF,CAEA,WAKE,yCAA0C,CAD1C,kBAAyB,CAAzB,wBAAyB,CADzB,iBAAkB,CADlB,UAAW,CADX,SAKF,CAEA,iBACE,MAAW,UAAY,CAAE,mBAAuB,CAChD,IAAM,SAAU,CAAE,kBAAqB,CACzC,CAGA,iBAEE,kBAAmB,CAMnB,aAAsB,CAAtB,qBAAsB,CAPtB,YAAa,CAKb,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CAHf,OAAQ,CADR,sBAAuB,CAMvB,oBAAsB,CAJtB,iBAKF","sources":["index.css","App.css"],"sourcesContent":["@import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;500;700&family=IBM+Plex+Mono:wght@300;400;500&display=swap');\n\n*, *::before, *::after {\n box-sizing: border-box;\n margin: 0;\n padding: 0;\n}\n\nbody {\n background: #0d0d14;\n color: #f8fafc;\n font-family: 'IBM Plex Mono', monospace;\n font-size: 13px;\n line-height: 1.5;\n -webkit-font-smoothing: antialiased;\n overflow-x: hidden;\n}\n\n::-webkit-scrollbar {\n width: 4px;\n height: 4px;\n}\n\n::-webkit-scrollbar-track {\n background: #0d0d14;\n}\n\n::-webkit-scrollbar-thumb {\n background: #2a2a3a;\n}\n\n::-webkit-scrollbar-thumb:hover {\n background: #3a3a5a;\n}\n",":root {\n --bg: #0d0d14;\n --surface: #13131d;\n --surface-2: #1a1a2e;\n --paper-white: #fafaf5;\n --paper-edge: #2a2a3a;\n --mountain: #f59e0b;\n --valley: #38bdf8;\n --target-ghost: rgba(124, 58, 237, 0.20);\n --target-ghost-stroke: rgba(124, 58, 237, 0.45);\n --validity: #22d3ee;\n --progress: #22c55e;\n --economy: #a78bfa;\n --text-primary: #f8fafc;\n --text-dim: #64748b;\n --border: #2a2a3a;\n --border-bright: #3a3a5a;\n --font-display: 'JetBrains Mono', monospace;\n --font-mono: 'IBM Plex Mono', monospace;\n}\n\n.app {\n display: flex;\n flex-direction: column;\n height: 100vh;\n background: var(--bg);\n overflow: hidden;\n}\n\n/* ─── HEADER ─── */\n.app-header {\n display: flex;\n align-items: center;\n gap: 24px;\n padding: 0 20px;\n height: 48px;\n border-bottom: 1px solid var(--border);\n background: var(--surface);\n flex-shrink: 0;\n z-index: 10;\n}\n\n.app-title {\n font-family: var(--font-display);\n font-size: 14px;\n font-weight: 700;\n letter-spacing: 0.12em;\n color: var(--text-primary);\n white-space: nowrap;\n}\n\n.app-title .title-accent {\n color: var(--mountain);\n}\n\n.header-sep {\n width: 1px;\n height: 24px;\n background: var(--border);\n flex-shrink: 0;\n}\n\n.header-right {\n display: flex;\n align-items: center;\n gap: 16px;\n margin-left: auto;\n}\n\n.replay-badge {\n font-size: 10px;\n font-family: var(--font-display);\n letter-spacing: 0.1em;\n color: #38bdf8;\n background: rgba(56, 189, 248, 0.1);\n border: 1px solid rgba(56, 189, 248, 0.3);\n padding: 3px 8px;\n border-radius: 3px;\n}\n\n.back-to-grid-btn {\n font-size: 10px;\n font-family: var(--font-display);\n letter-spacing: 0.08em;\n color: #64748b;\n background: transparent;\n border: 1px solid #1e2a3a;\n padding: 3px 10px;\n border-radius: 3px;\n cursor: pointer;\n}\n.back-to-grid-btn:hover { color: #e2e8f0; border-color: #64748b; }\n\n.api-status {\n font-size: 11px;\n font-family: var(--font-display);\n letter-spacing: 0.08em;\n display: flex;\n align-items: center;\n gap: 6px;\n}\n\n.api-status-dot {\n width: 6px;\n height: 6px;\n border-radius: 50%;\n background: var(--text-dim);\n}\n\n.api-status-dot.ok {\n background: var(--progress);\n box-shadow: 0 0 6px var(--progress);\n}\n\n.api-status-dot.err {\n background: #ef4444;\n box-shadow: 0 0 6px #ef4444;\n}\n\n/* ─── MAIN LAYOUT ─── */\n.app-body {\n display: grid;\n grid-template-columns: 1fr 280px;\n flex: 1;\n overflow: hidden;\n}\n\n.app-left {\n display: flex;\n flex-direction: column;\n overflow: hidden;\n border-right: 1px solid var(--border);\n}\n\n.app-right {\n display: flex;\n flex-direction: column;\n overflow: hidden;\n background: var(--surface);\n}\n\n/* ─── CANVAS ROW ─── */\n.canvas-row {\n display: flex;\n gap: 0;\n padding: 16px;\n flex-shrink: 0;\n border-bottom: 1px solid var(--border);\n overflow-x: auto;\n}\n\n.canvas-wrap {\n display: flex;\n flex-direction: column;\n gap: 8px;\n flex: 1;\n min-width: 280px;\n}\n\n.canvas-wrap + .canvas-wrap {\n margin-left: 16px;\n}\n\n.canvas-label {\n font-family: var(--font-display);\n font-size: 10px;\n font-weight: 500;\n letter-spacing: 0.14em;\n color: var(--text-dim);\n text-transform: uppercase;\n}\n\n.canvas-svg {\n display: block;\n background: var(--paper-white);\n}\n\n.canvas-3d {\n display: block;\n background: linear-gradient(180deg, #1a1a2e 0%, #0f101a 100%);\n border: 1px solid var(--border);\n}\n\n.canvas-label-row {\n display: flex;\n align-items: center;\n justify-content: space-between;\n gap: 10px;\n}\n\n.fold-mode-toggle {\n display: inline-flex;\n border: 1px solid var(--border);\n background: var(--surface);\n}\n\n.fold-mode-btn {\n border: none;\n background: transparent;\n color: var(--text-dim);\n font-family: var(--font-display);\n font-size: 9px;\n letter-spacing: 0.08em;\n padding: 3px 7px;\n cursor: pointer;\n}\n\n.fold-mode-btn + .fold-mode-btn {\n border-left: 1px solid var(--border);\n}\n\n.fold-mode-btn.active {\n color: var(--text-primary);\n background: #1f2538;\n}\n\n/* ─── STEP FEED ─── */\n.step-feed-section {\n flex: 1;\n display: flex;\n flex-direction: column;\n overflow: hidden;\n}\n\n.section-header {\n font-family: var(--font-display);\n font-size: 10px;\n font-weight: 500;\n letter-spacing: 0.14em;\n color: var(--text-dim);\n text-transform: uppercase;\n padding: 8px 16px;\n border-bottom: 1px solid var(--border);\n flex-shrink: 0;\n}\n\n.step-feed {\n overflow-y: auto;\n flex: 1;\n padding: 4px 0;\n}\n\n.step-entry {\n display: flex;\n flex-direction: column;\n gap: 2px;\n padding: 8px 16px;\n border-bottom: 1px solid var(--border);\n cursor: default;\n transition: background 0.1s;\n}\n\n.step-entry:hover {\n background: var(--surface);\n}\n\n.step-entry.active {\n background: var(--surface-2);\n border-left: 2px solid var(--valley);\n padding-left: 14px;\n}\n\n.step-entry-top {\n display: flex;\n align-items: center;\n gap: 8px;\n}\n\n.step-num {\n font-family: var(--font-display);\n font-size: 10px;\n font-weight: 700;\n color: var(--text-dim);\n width: 24px;\n flex-shrink: 0;\n}\n\n.step-instruction {\n font-size: 12px;\n color: var(--text-primary);\n flex: 1;\n}\n\n.assign-badge {\n font-family: var(--font-display);\n font-size: 10px;\n font-weight: 700;\n padding: 1px 5px;\n line-height: 1.4;\n flex-shrink: 0;\n}\n\n.assign-badge.M {\n background: var(--mountain);\n color: #0d0d14;\n}\n\n.assign-badge.V {\n background: var(--valley);\n color: #0d0d14;\n}\n\n.assign-badge.B {\n background: var(--border-bright);\n color: var(--text-dim);\n}\n\n.step-reward-delta {\n font-size: 11px;\n color: var(--text-dim);\n padding-left: 32px;\n}\n\n.step-reward-delta .delta-positive {\n color: var(--progress);\n}\n\n.step-reward-delta .delta-negative {\n color: #ef4444;\n}\n\n/* ─── REWARD PANEL ─── */\n.reward-panel {\n padding: 12px 16px;\n border-bottom: 1px solid var(--border);\n flex-shrink: 0;\n}\n\n.reward-row {\n display: flex;\n align-items: center;\n gap: 8px;\n margin-bottom: 6px;\n}\n\n.reward-row:last-child {\n margin-bottom: 0;\n}\n\n.reward-label {\n font-family: var(--font-display);\n font-size: 10px;\n font-weight: 500;\n letter-spacing: 0.06em;\n color: var(--text-dim);\n width: 72px;\n flex-shrink: 0;\n text-transform: uppercase;\n}\n\n.reward-track {\n flex: 1;\n height: 8px;\n background: var(--bg);\n border: 1px solid var(--border);\n overflow: hidden;\n}\n\n.reward-bar {\n height: 100%;\n transition: width 0.4s ease;\n}\n\n.reward-value {\n font-family: var(--font-display);\n font-size: 11px;\n font-weight: 500;\n color: var(--text-primary);\n width: 36px;\n text-align: right;\n flex-shrink: 0;\n}\n\n.reward-value.dim {\n color: var(--text-dim);\n}\n\n.reward-divider {\n height: 1px;\n background: var(--border);\n margin: 6px 0;\n}\n\n/* ─── INFO BADGES ─── */\n.info-badges {\n padding: 12px 16px;\n display: flex;\n flex-direction: column;\n gap: 8px;\n}\n\n.info-row {\n display: flex;\n align-items: center;\n justify-content: space-between;\n gap: 8px;\n}\n\n.info-key {\n font-family: var(--font-display);\n font-size: 10px;\n font-weight: 500;\n letter-spacing: 0.06em;\n color: var(--text-dim);\n text-transform: uppercase;\n}\n\n.info-val {\n font-family: var(--font-display);\n font-size: 11px;\n font-weight: 700;\n color: var(--text-primary);\n}\n\n.info-val.bool-true {\n color: var(--progress);\n}\n\n.info-val.bool-false {\n color: #ef4444;\n}\n\n.info-val.dim {\n color: var(--text-dim);\n}\n\n/* ─── TARGET SELECTOR ─── */\n.target-selector {\n display: flex;\n align-items: center;\n gap: 8px;\n}\n\n.target-selector-label {\n font-family: var(--font-display);\n font-size: 10px;\n font-weight: 500;\n letter-spacing: 0.10em;\n color: var(--text-dim);\n text-transform: uppercase;\n white-space: nowrap;\n}\n\n.target-select {\n background: var(--surface-2);\n border: 1px solid var(--border-bright);\n color: var(--text-primary);\n font-family: var(--font-display);\n font-size: 11px;\n padding: 4px 8px;\n outline: none;\n cursor: pointer;\n min-width: 180px;\n}\n\n.target-select:focus {\n border-color: var(--valley);\n}\n\noptgroup {\n background: var(--surface);\n color: var(--text-dim);\n font-family: var(--font-display);\n font-size: 10px;\n}\n\noption {\n background: var(--surface-2);\n color: var(--text-primary);\n font-family: var(--font-display);\n}\n\n/* ─── PLAYER CONTROLS ─── */\n.player-controls {\n display: flex;\n align-items: center;\n gap: 6px;\n flex-shrink: 0;\n}\n\n.ctrl-btn {\n background: var(--surface-2);\n border: 1px solid var(--border-bright);\n color: var(--text-primary);\n font-family: var(--font-display);\n font-size: 11px;\n font-weight: 500;\n padding: 4px 10px;\n cursor: pointer;\n white-space: nowrap;\n line-height: 1.4;\n letter-spacing: 0.04em;\n transition: background 0.1s, border-color 0.1s;\n}\n\n.ctrl-btn:hover:not(:disabled) {\n background: var(--surface);\n border-color: var(--text-dim);\n}\n\n.ctrl-btn:disabled {\n opacity: 0.35;\n cursor: not-allowed;\n}\n\n.ctrl-btn.play {\n border-color: var(--valley);\n color: var(--valley);\n}\n\n.ctrl-btn.play:hover:not(:disabled) {\n background: rgba(56, 189, 248, 0.1);\n}\n\n.ctrl-step-display {\n font-family: var(--font-display);\n font-size: 11px;\n color: var(--text-dim);\n padding: 4px 8px;\n border: 1px solid var(--border);\n background: var(--bg);\n white-space: nowrap;\n min-width: 72px;\n text-align: center;\n}\n\n/* ─── LOADING / ERROR ─── */\n.app-overlay {\n position: fixed;\n inset: 0;\n display: flex;\n align-items: center;\n justify-content: center;\n background: var(--bg);\n z-index: 100;\n}\n\n.overlay-message {\n font-family: var(--font-display);\n font-size: 13px;\n letter-spacing: 0.1em;\n color: var(--text-dim);\n display: flex;\n align-items: center;\n gap: 12px;\n}\n\n.pulse-dot {\n width: 8px;\n height: 8px;\n border-radius: 50%;\n background: var(--valley);\n animation: pulse 1.2s ease-in-out infinite;\n}\n\n@keyframes pulse {\n 0%, 100% { opacity: 0.2; transform: scale(0.8); }\n 50% { opacity: 1; transform: scale(1); }\n}\n\n/* ─── MISC ─── */\n.episode-loading {\n display: flex;\n align-items: center;\n justify-content: center;\n gap: 8px;\n padding: 12px 16px;\n font-family: var(--font-display);\n font-size: 11px;\n color: var(--text-dim);\n letter-spacing: 0.08em;\n}\n"],"names":[],"sourceRoot":""}

build/static/js/main.b94094b6.js ADDED Viewed

The diff for this file is too large to render. See raw diff

build/static/js/main.b94094b6.js.LICENSE.txt ADDED Viewed

	@@ -0,0 +1,49 @@

+/**
+ * @license React
+ * react-dom-client.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @license React
+ * react-dom.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @license React
+ * react.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @license React
+ * scheduler.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */

build/static/js/main.b94094b6.js.map ADDED Viewed

The diff for this file is too large to render. See raw diff

docs/optigami_handoff.md ADDED Viewed

	@@ -0,0 +1,767 @@

+# OrigamiRL — OpenEnv Hackathon Handoff Document
+## TL;DR
+Build the **first multi-turn RL environment where an LLM learns to generate origami folding instructions**, verified by a computational origami simulator. Target the OpenEnv Hackathon (March 7-8, 2026, SF — $100K+ in prizes). Use OpenEnv spec + Unsloth GRPO for training. Dense verifiable rewards from origami geometry theorems (Kawasaki, Maekawa). No learned reward model needed.
+---
+## Hackathon Context
+- **Event:** OpenEnv Hackathon SF, hosted by Cerebral Valley + Shack15 + Meta/PyTorch
+- **Date:** March 7-8, 2026 (happening NOW)
+- **Prize:** $100K+ cash
+- **Teams:** Up to 4 people
+- **Format:** Build RL environments, post-train a base model
+### Judging Criteria
+| Category | Weight | What Matters |
+|----------|--------|-------------|
+| Environment Innovation | 40% | Novel, creative, challenging. Does it meaningfully test agent behavior? |
+| Storytelling | 30% | Clear problem explanation, engaging demo, easy to follow |
+| Training Script Showing Improvement | 20% | Observable reward curves, before/after behavior |
+| Reward and Training Pipeline Setup | 10% | Coherent reward logic, meaningful improvement in inference |
+### Key Sponsors to Impress
+- **Meta/PyTorch** — OpenEnv creators, want environments using their spec
+- **Unsloth AI** — GRPO training infra, ART (Agent Reinforcement Trainer). USE THEIR TOOLS.
+- **OpenPipe** — ART trainer (frontend/backend split for GRPO). Also use.
+- **Patronus AI** — Building "generative simulators" (auto-scaling RL environments). They care about curriculum difficulty scaling and verifiable rewards.
+- **Snorkel AI** — "2026 is the year of environments." They care about data quality and environment diversity.
+- **Hugging Face** — OpenEnv Hub, want environments deployed there
+- **Scale AI / Mercor** — Agent evaluation, structured task environments
+---
+## The Pitch (for judges)
+> "Spatial reasoning is the next frontier for LLM training — NeurIPS 2025 papers like OrigamiSpace showed that even GPT-5 fails at multi-step origami reasoning. But those are benchmarks, not training environments. We built OrigamiRL: the first multi-turn RL environment where an LLM agent learns to fold paper by outputting instructions, receiving geometric feedback, and improving through GRPO. Our reward function is fully verifiable — fold validity is checked against computational origami axioms, not an LLM judge. We built it on OpenEnv + Unsloth with a natural curriculum from single folds to full cranes."
+---
+## Prior Work (What Exists, Where the Gaps Are)
+### 1. OrigamiSpace (NeurIPS 2025 Spotlight)
+- **Paper:** https://arxiv.org/abs/2511.18450
+- **What it is:** Benchmark with 350 origami data instances (CP diagrams, folding processes, folded shapes). 4 evaluation tasks: Pattern Prediction, Multi-step Spatial Reasoning, Spatial Relationship Prediction, End-to-End CP Code Generation.
+- **Their compiler:** Outputs detailed flattened diagrams with crease locations and stacking relationships, supports interactive simulation with MLLMs, provides comprehensive error feedback. Checks: syntax validity, geometric foldability, no self-intersections, Kawasaki's theorem, Maekawa's theorem.
+- **Their reward metrics for code gen:** Hausdorff distance (shape similarity), dihedral angle distribution, bounding box aspect ratios, constraint satisfaction.
+- **Difficulty levels:** Easy (3-9 steps), Medium (10-19 steps), Hard (20-30 steps)
+- **Gap:** Single-turn only (LLM generates complete CP code in one shot). They mention RL exploration but it's not the focus. No multi-turn sequential folding.
+### 2. GamiBench (Dec 2025)
+- **Paper:** https://arxiv.org/abs/2512.22207
+- **What it is:** 186 regular + 186 impossible 2D crease patterns with 3D folded shapes from 6 viewpoints. 3 VQA tasks.
+- **Gap:** Evaluation-only, no training. Tests single-step spatial understanding.
+### 3. SpatialThinker (NeurIPS 2025)
+- **Paper:** https://arxiv.org/abs/2511.07403
+- **What it is:** 3D-aware MLLM trained with RL using dense spatial rewards. Constructs scene graphs. Multi-objective reward with lexicographic gating.
+- **Key architecture to steal:** Dense reward design with lexicographic ordering — format → count → accuracy → spatial. Nearly doubled RL training gains vs sparse rewards. Only needed 7K training samples with GRPO.
+- **Gap:** Static scene understanding (objects on a table), not sequential physical transformations.
+### 4. rigid-origami Gym (IJCAI 2023)
+- **Repo:** https://github.com/belalugaX/rigid-origami
+- **Paper:** "Automating Rigid Origami Design" (https://arxiv.org/abs/2211.13219)
+- **What it is:** Gym environment where agent constructs crease pattern graphs on a board. Sparse rewards. Foldability validated by triangle intersection tests + kinematic rigidity model. Game terminates on non-foldable states.
+- **Gap:** Classical RL agents (discrete grid actions), NOT LLMs generating text. Rigid-origami tessellations only, not traditional origami. No natural language.
+### 5. The Unique Gap We Fill
+Nobody has built a model that reasons about **sequential 2D-to-3D geometric transformations with physical constraints** through **natural language instructions** in a **multi-turn RL training loop**. Origami is uniquely hard because it requires tracking how a flat sheet's topology changes through a sequence of folds — mental rotation, spatial visualization, and perspective-taking all at once.
+---
+## Environment Design
+### Architecture Overview
+```
++---------------------------------------------------+
+|                   OpenEnv Server                   |
+|  +-----------+  +----------+  +--------------+    |
+|  |   State   |  |  Action  |  |   Reward     |    |
+|  | (FOLD JSON|  | (LLM     |  | (Dense,      |    |
+|  |  + target)|  |  output) |  |  verifiable) |    |
+|  +-----------+  +----------+  +--------------+    |
+|         |              |              |            |
+|         v              v              v            |
+|  +-----------------------------------------------+|
+|  |         Paper Geometry Engine (Python)         ||
+|  |  - Polygon state (Shapely)                    ||
+|  |  - Fold operations (reflection across line)   ||
+|  |  - Kawasaki/Maekawa constraint checks         ||
+|  |  - Layer tracking                             ||
+|  |  - FOLD format import/export                  ||
+|  +-----------------------------------------------+|
+|         |                                          |
+|         v                                          |
+|  +-----------------------------------------------+|
+|  |         Three.js Visualizer (Demo only)        ||
+|  |  - 3D fold animation                          ||
+|  |  - Strain heatmap                             ||
+|  |  - Instruction stream                         ||
+|  +-----------------------------------------------+|
++---------------------------------------------------+
+         |                    ^
+         v                    |
++---------------------------------------------------+
+|              Unsloth ART / GRPO Trainer            |
+|  - Qwen2.5-VL-7B or Qwen3-4B base model          |
+|  - LoRA/QLoRA for efficient training              |
+|  - Multi-turn rollouts                            |
++---------------------------------------------------+
+```
+### OpenEnv Spec Compliance
+Must implement these APIs:
+```python
+class OrigamiEnv:
+    async def reset() -> Observation     # New episode: flat paper + target
+    async def step(action) -> (Observation, reward, done, info)
+    async def state() -> State           # Current paper geometry
+    async def close()                    # Cleanup
+```
+OpenEnv repo: https://github.com/meta-pytorch/OpenEnv
+Install: `pip install -e .` then `openenv init origami_env`
+### State Space
+```python
+@dataclass
+class OrigamiState:
+    # Current paper geometry
+    vertices: List[Tuple[float, float]]       # 2D vertex positions
+    edges: List[Tuple[int, int]]              # Edge connectivity
+    edges_assignment: List[str]               # 'M', 'V', 'B', 'F' (mountain/valley/boundary/flat)
+    edges_foldAngle: List[float]              # -180 to 180 degrees
+    faces: List[List[int]]                    # Face vertex indices
+    layer_order: List[List[int]]              # Face stacking order
+    # Episode context
+    target_crease_pattern: dict               # Target FOLD JSON
+    target_shape_image: Optional[np.ndarray]  # Target folded shape (for multimodal)
+    instruction_history: List[str]            # Previous instructions
+    step_count: int
+    max_steps: int
+```
+This maps directly to the **FOLD format** (JSON-based, used by all origami software):
+```json
+{
+  "vertices_coords": [[0,0], [1,0], [1,1], [0,1]],
+  "edges_vertices": [[0,1], [1,2], [2,3], [3,0]],
+  "edges_assignment": ["B", "B", "B", "B"],
+  "edges_foldAngle": [0, 0, 0, 0],
+  "faces_vertices": [[0, 1, 2, 3]]
+}
+```
+FOLD spec: https://github.com/edemaine/fold
+FOLD JS library: https://edemaine.github.io/fold/
+### Action Space
+The LLM outputs a JSON action:
+```json
+{
+  "instruction": "Fold the top edge down to meet the bottom edge",
+  "fold_line": [[0, 0.5], [1, 0.5]],
+  "fold_angle": -180,
+  "assignment": "V"
+}
+```
+The `instruction` field is natural language (what we're training the model to produce well). The geometric fields are the verifiable representation. During training, the model outputs both; for the final demo, the NL instruction is the star.
+Alternative simpler action (for early iterations):
+```json
+{
+  "instruction": "Valley fold along the horizontal center line",
+  "fold_type": "valley",
+  "fold_axis": "horizontal",
+  "fold_position": 0.5
+}
+```
+### Reward Function — Dense, Multi-Objective, Lexicographically Gated
+Inspired by SpatialThinker's design. Rewards are computed in order; later rewards only apply if earlier gates pass.
+```python
+def compute_reward(state, action, new_state, target) -> dict:
+    rewards = {}
+    # LEVEL 1: Format (gate for everything else)
+    # Does the output parse into a valid fold operation?
+    rewards['format'] = 1.0 if parseable(action) else 0.0
+    if rewards['format'] == 0:
+        return rewards  # Stop here
+    # LEVEL 2: Local Geometric Validity
+    # Kawasaki's theorem: sector angles at each interior vertex sum to 2pi
+    kawasaki_valid = check_kawasaki(new_state)
+    # Maekawa's theorem: |M - V| = 2 at each interior vertex
+    maekawa_valid = check_maekawa(new_state)
+    # No self-intersection
+    no_intersection = check_no_self_intersection(new_state)
+    rewards['validity'] = (kawasaki_valid + maekawa_valid + no_intersection) / 3.0
+    if rewards['validity'] < 0.5:
+        return rewards  # Stop here
+    # LEVEL 3: Physical Feasibility
+    # Can this fold actually be performed given layer stack?
+    layer_consistent = check_layer_ordering(new_state)
+    fold_achievable = check_fold_angle_feasible(new_state)
+    rewards['feasibility'] = (layer_consistent + fold_achievable) / 2.0
+    # LEVEL 4: Progress Toward Target (Dense)
+    # Crease pattern graph similarity
+    cp_similarity = crease_pattern_similarity(new_state, target)
+    # Fold angle distribution match
+    angle_similarity = fold_angle_distribution_match(new_state, target)
+    # Bounding box aspect ratio match
+    bbox_similarity = bounding_box_similarity(new_state, target)
+    rewards['progress'] = 0.4 * cp_similarity + 0.4 * angle_similarity + 0.2 * bbox_similarity
+    # LEVEL 5: Completion Bonus
+    if shape_matches_target(new_state, target, tolerance=0.05):
+        rewards['completion'] = 10.0
+    # LEVEL 6: Efficiency
+    rewards['efficiency'] = -0.01  # Small step penalty to encourage fewer folds
+    # Total
+    rewards['total'] = (
+        0.1 * rewards['format'] +
+        0.2 * rewards['validity'] +
+        0.1 * rewards['feasibility'] +
+        0.5 * rewards['progress'] +
+        rewards.get('completion', 0) +
+        rewards['efficiency']
+    )
+    return rewards
+```
+### Key Origami Theorems for Verification
+These are the verifiable constraints — the "unit tests" of origami:
+1. **Kawasaki's Theorem:** At any interior vertex of a flat-foldable crease pattern, the alternating sum of sector angles equals zero (equivalently, they sum to 2pi on each side). NECESSARY condition for flat-foldability.
+2. **Maekawa's Theorem:** At any interior vertex, the number of mountain folds minus valley folds equals +/-2. |M - V| = 2.
+3. **No self-intersection:** Faces cannot penetrate each other during folding.
+4. **Euler's formula for planar graphs:** V - E + F = 2 (sanity check on graph structure).
+5. **Huzita-Hatori axioms:** The 7 axioms defining all possible single-fold operations (point-to-point, point-to-line, line-to-line, etc.). These define the VALID action space.
+### Curriculum Design
+| Level | Folds | Examples | Complexity |
+|-------|-------|----------|-----------|
+| 1 | 1 | Valley fold in half, mountain fold corner | Single fold validity |
+| 2 | 2-3 | Paper airplane nose, triangle fold | Sequential dependency |
+| 3 | 4-6 | Simple boat, fortune teller | Multi-step with symmetry |
+| 4 | 7-12 | Paper airplane (full), jumping frog | Longer horizon planning |
+| 5 | 13-20 | Crane, lily | Complex spatial tracking |
+For the hackathon, focus on Levels 1-3. Even showing reward improvement on Level 1-2 is a strong result.
+---
+## Core Implementation: Python Geometry Engine
+This is the MOST IMPORTANT piece. Pure Python, no JS dependencies.
+```python
+import numpy as np
+from shapely.geometry import Polygon, LineString, MultiPolygon
+from shapely.ops import split
+from typing import List, Tuple, Dict
+import json
+class PaperState:
+    """Represents the current state of the origami paper."""
+    def __init__(self, size: float = 1.0):
+        # Start with a unit square
+        self.regions = [Polygon([(0,0), (size,0), (size,size), (0,size)])]
+        self.fold_history = []
+        self.crease_lines = []
+        self.crease_assignments = []  # 'M' or 'V'
+        self.crease_angles = []
+        self.layer_order = [0]  # Stack order of regions
+    def apply_fold(self, fold_line: LineString, angle: float, assignment: str) -> dict:
+        """
+        Apply a fold operation. Returns dict with validity info.
+        fold_line: Shapely LineString defining the fold axis
+        angle: fold angle in degrees (-180 to 180)
+        assignment: 'M' (mountain) or 'V' (valley)
+        """
+        result = {'valid': True, 'errors': []}
+        # 1. Split regions by fold line
+        new_regions = []
+        for region in self.regions:
+            if fold_line.intersects(region):
+                parts = split(region, fold_line)
+                new_regions.extend(parts.geoms)
+            else:
+                new_regions.append(region)
+        # 2. Determine which side folds (based on assignment)
+        folding_side = []
+        staying_side = []
+        for region in new_regions:
+            centroid = region.centroid
+            side = self._point_side(centroid, fold_line)
+            if side > 0:
+                folding_side.append(region)
+            else:
+                staying_side.append(region)
+        # 3. Reflect folding regions across fold line
+        reflected = [self._reflect_polygon(r, fold_line) for r in folding_side]
+        # 4. Update state
+        self.regions = staying_side + reflected
+        self.crease_lines.append(fold_line)
+        self.crease_assignments.append(assignment)
+        self.crease_angles.append(angle)
+        self.fold_history.append({
+            'line': list(fold_line.coords),
+            'angle': angle,
+            'assignment': assignment
+        })
+        # 5. Update layer order
+        self._update_layer_order(staying_side, reflected)
+        return result
+    def _reflect_polygon(self, poly: Polygon, line: LineString) -> Polygon:
+        """Reflect a polygon across a line."""
+        coords = list(poly.exterior.coords)
+        reflected_coords = [self._reflect_point(p, line) for p in coords]
+        return Polygon(reflected_coords)
+    def _reflect_point(self, point: tuple, line: LineString) -> tuple:
+        """Reflect a point across a line."""
+        p = np.array(point[:2])
+        l1 = np.array(line.coords[0])
+        l2 = np.array(line.coords[1])
+        d = l2 - l1
+        d = d / np.linalg.norm(d)
+        # Reflection formula: p' = p - 2(p-l1).n * n where n is normal to line
+        n = np.array([-d[1], d[0]])
+        v = p - l1
+        return tuple(p - 2 * np.dot(v, n) * n)
+    def _point_side(self, point, line: LineString) -> float:
+        """Returns positive if point is on left side of line, negative if right."""
+        p = np.array([point.x, point.y])
+        l1 = np.array(line.coords[0])
+        l2 = np.array(line.coords[1])
+        return float(np.cross(l2 - l1, p - l1))
+    def _update_layer_order(self, staying, reflected):
+        """Update the layer stacking order after a fold."""
+        self.layer_order = list(range(len(staying))) + \
+                          list(range(len(staying), len(staying) + len(reflected)))
+    def to_fold_json(self) -> dict:
+        """Export current state as FOLD format JSON."""
+        vertices = set()
+        for line in self.crease_lines:
+            for coord in line.coords:
+                vertices.add(tuple(round(c, 10) for c in coord))
+        # Add boundary vertices
+        for region in self.regions:
+            for coord in region.exterior.coords:
+                vertices.add(tuple(round(c, 10) for c in coord[:2]))
+        vertices = sorted(list(vertices))
+        vertex_map = {v: i for i, v in enumerate(vertices)}
+        edge_set = set()
+        edges_list = []
+        assignments_list = []
+        angles_list = []
+        # Add crease edges
+        for i, line in enumerate(self.crease_lines):
+            c = [tuple(round(x, 10) for x in coord) for coord in line.coords]
+            edge = tuple(sorted([vertex_map[c[0]], vertex_map[c[1]]]))
+            if edge not in edge_set:
+                edge_set.add(edge)
+                edges_list.append(list(edge))
+                assignments_list.append(self.crease_assignments[i])
+                angles_list.append(self.crease_angles[i])
+        return {
+            'vertices_coords': [list(v) for v in vertices],
+            'edges_vertices': edges_list,
+            'edges_assignment': assignments_list,
+            'edges_foldAngle': angles_list,
+        }
+class OrigamiVerifier:
+    """Verifiable reward functions based on origami theorems."""
+    @staticmethod
+    def check_kawasaki(state: PaperState) -> bool:
+        """Kawasaki's theorem: alternating sum of angles at each interior vertex = 0."""
+        fold_json = state.to_fold_json()
+        vertices = fold_json['vertices_coords']
+        edges = fold_json['edges_vertices']
+        for v_idx in range(len(vertices)):
+            v = vertices[v_idx]
+            incident_edges = [e for e in edges if v_idx in e]
+            if len(incident_edges) < 4:
+                continue  # Need degree-4+ for Kawasaki
+            # Calculate sector angles
+            angles = []
+            for e in incident_edges:
+                other = e[1] if e[0] == v_idx else e[0]
+                other_v = vertices[other]
+                angle = np.arctan2(other_v[1] - v[1], other_v[0] - v[0])
+                angles.append(angle)
+            angles.sort()
+            sector_angles = []
+            for i in range(len(angles) - 1):
+                sector_angles.append(angles[i+1] - angles[i])
+            sector_angles.append(2*np.pi - (angles[-1] - angles[0]))
+            # Kawasaki: alternating sum should be ~0
+            if len(sector_angles) >= 4:
+                alt_sum = sum(sector_angles[::2]) - sum(sector_angles[1::2])
+                if abs(alt_sum) > 0.01:
+                    return False
+        return True
+    @staticmethod
+    def check_maekawa(state: PaperState) -> bool:
+        """Maekawa's theorem: |M - V| = 2 at each interior vertex."""
+        fold_json = state.to_fold_json()
+        vertices = fold_json['vertices_coords']
+        edges = fold_json['edges_vertices']
+        assignments = fold_json['edges_assignment']
+        for v_idx in range(len(vertices)):
+            incident = [(i, e) for i, e in enumerate(edges) if v_idx in e]
+            m_count = sum(1 for i, _ in incident if i < len(assignments) and assignments[i] == 'M')
+            v_count = sum(1 for i, _ in incident if i < len(assignments) and assignments[i] == 'V')
+            if m_count + v_count >= 4:  # Interior vertex with folds
+                if abs(m_count - v_count) != 2:
+                    return False
+        return True
+    @staticmethod
+    def crease_pattern_similarity(state: PaperState, target_fold_json: dict) -> float:
+        """Compare current crease pattern to target. Returns 0-1 similarity."""
+        current = state.to_fold_json()
+        n_current = len(current.get('edges_vertices', []))
+        n_target = len(target_fold_json.get('edges_vertices', []))
+        if n_target == 0:
+            return 1.0 if n_current == 0 else 0.0
+        edge_count_sim = 1.0 - abs(n_current - n_target) / max(n_target, 1)
+        edge_count_sim = max(0, edge_count_sim)
+        current_assignments = current.get('edges_assignment', [])
+        target_assignments = target_fold_json.get('edges_assignment', [])
+        c_m = current_assignments.count('M')
+        c_v = current_assignments.count('V')
+        t_m = target_assignments.count('M')
+        t_v = target_assignments.count('V')
+        total = max(t_m + t_v, 1)
+        assign_sim = 1.0 - (abs(c_m - t_m) + abs(c_v - t_v)) / (2 * total)
+        assign_sim = max(0, assign_sim)
+        return 0.5 * edge_count_sim + 0.5 * assign_sim
+```
+---
+## OpenEnv Environment Wrapper
+```python
+# origami_env/server.py
+from openenv.core import Environment
+from paper_engine import PaperState, OrigamiVerifier
+from shapely.geometry import LineString
+import json
+class OrigamiEnvironment(Environment):
+    def __init__(self, targets_dir="targets/", max_steps=20):
+        self.targets_dir = targets_dir
+        self.max_steps = max_steps
+        self.paper = None
+        self.target = None
+        self.step_count = 0
+    async def reset(self, target_id=None):
+        self.paper = PaperState(size=1.0)
+        self.target = self._load_target(target_id)
+        self.step_count = 0
+        return self._get_observation()
+    async def step(self, action):
+        self.step_count += 1
+        # Parse action
+        try:
+            fold_line = LineString(action['fold_line'])
+            angle = action['fold_angle']
+            assignment = action['assignment']
+        except (KeyError, Exception):
+            reward = {'format': 0, 'total': -0.1}
+            return self._get_observation(), reward, False, {'error': 'parse_failed'}
+        # Apply fold
+        result = self.paper.apply_fold(fold_line, angle, assignment)
+        # Compute rewards
+        reward = self._compute_reward(result)
+        # Check termination
+        done = (
+            self.step_count >= self.max_steps or
+            reward.get('completion', 0) > 0
+        )
+        return self._get_observation(), reward, done, {}
+    async def state(self):
+        return {
+            'paper': self.paper.to_fold_json(),
+            'target': self.target,
+            'step': self.step_count,
+            'fold_history': self.paper.fold_history
+        }
+    def _compute_reward(self, fold_result):
+        rewards = {}
+        rewards['format'] = 1.0
+        kawasaki = OrigamiVerifier.check_kawasaki(self.paper)
+        maekawa = OrigamiVerifier.check_maekawa(self.paper)
+        rewards['validity'] = (float(kawasaki) + float(maekawa)) / 2.0
+        rewards['progress'] = OrigamiVerifier.crease_pattern_similarity(
+            self.paper, self.target
+        )
+        if rewards['progress'] > 0.95:
+            rewards['completion'] = 10.0
+        rewards['efficiency'] = -0.01
+        rewards['total'] = (
+            0.1 * rewards['format'] +
+            0.2 * rewards['validity'] +
+            0.6 * rewards['progress'] +
+            rewards.get('completion', 0) +
+            rewards['efficiency']
+        )
+        return rewards
+    def _get_observation(self):
+        return {
+            'paper_state': self.paper.to_fold_json(),
+            'target': self.target,
+            'step': self.step_count,
+            'instruction_history': [str(f['line']) for f in self.paper.fold_history]
+        }
+    def _load_target(self, target_id):
+        if target_id:
+            with open(f"{self.targets_dir}/{target_id}.fold") as f:
+                return json.load(f)
+        # Default: simple valley fold in half
+        return {
+            'vertices_coords': [[0,0], [1,0], [1,1], [0,1], [0,0.5], [1,0.5]],
+            'edges_vertices': [[0,1], [1,2], [2,3], [3,0], [4,5]],
+            'edges_assignment': ['B', 'B', 'B', 'B', 'V'],
+            'edges_foldAngle': [0, 0, 0, 0, -180],
+        }
+```
+---
+## Training Script (Unsloth GRPO)
+```python
+# train.py
+from unsloth import FastLanguageModel
+from trl import GRPOConfig, GRPOTrainer
+import torch
+# Load model
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name="unsloth/Qwen2.5-7B-Instruct",
+    max_seq_length=4096,
+    load_in_4bit=True,
+)
+# Add LoRA
+model = FastLanguageModel.get_peft_model(
+    model,
+    r=32,
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
+                     "gate_proj", "up_proj", "down_proj"],
+    lora_alpha=32,
+    lora_dropout=0,
+    use_gradient_checkpointing="unsloth",
+)
+# Reward function
+def origami_reward(completions, prompts):
+    """Compute rewards for a batch of completions."""
+    rewards = []
+    for completion in completions:
+        try:
+            action = parse_fold_action(completion)
+            paper = PaperState()
+            result = paper.apply_fold(action['fold_line'], action['angle'], action['assignment'])
+            r = compute_reward(paper, target)
+            rewards.append(r['total'])
+        except Exception:
+            rewards.append(-0.1)
+    return rewards
+# GRPO Config
+config = GRPOConfig(
+    output_dir="origami-grpo",
+    num_train_epochs=3,
+    per_device_train_batch_size=4,
+    gradient_accumulation_steps=4,
+    learning_rate=5e-6,
+    max_completion_length=512,
+    num_generations=8,
+    temperature=1.0,
+    logging_steps=1,
+)
+dataset = load_origami_prompts()
+trainer = GRPOTrainer(
+    model=model,
+    config=config,
+    train_dataset=dataset,
+    reward_funcs=[origami_reward],
+    tokenizer=tokenizer,
+)
+trainer.train()
+```
+---
+## Visualization (Demo Only — Not in Training Loop)
+### Options
+1. **Origami Simulator** — https://github.com/amandaghassaei/OrigamiSimulator — Three.js, accepts FOLD files, shows folding animation with strain visualization
+2. **PackCAD** — https://packcad.com/ — Web-based, SVG crease patterns, rigid folding simulation
+3. **Custom Three.js** — Simpler but more control
+### Demo UI Layout
+```
++----------------------+----------------------+
+|   Instruction Stream |   3D Fold Viewer     |
+|                      |                      |
+| Step 1: Valley fold  |   [Three.js canvas]  |
+| along center [OK]    |                      |
+|                      |   Paper animating    |
+| Step 2: Fold top     |   fold by fold       |
+| corners to center    |                      |
+|                      |                      |
++----------------------+----------------------+
+|   Reward Dashboard                          |
+|   Format:   ========== 1.0                  |
+|   Validity: ========.. 0.8                  |
+|   Progress: ======.... 0.6                  |
+|   Total:    =======... 0.72                 |
+|                                              |
+|   [Reward curve over training steps]         |
++----------------------------------------------+
+```
+---
+## Key Libraries and Resources
+| Tool | Purpose | Link |
+|------|---------|------|
+| OpenEnv | Environment framework | https://github.com/meta-pytorch/OpenEnv |
+| Unsloth | GRPO training | https://github.com/unslothai/unsloth |
+| OpenPipe ART | Multi-turn RL trainer | https://github.com/OpenPipe/ART |
+| FOLD format | Origami data structure | https://github.com/edemaine/fold |
+| Rabbit Ear | JS origami library | https://github.com/rabbit-ear/rabbit-ear |
+| Origami Simulator | 3D visualization | https://github.com/amandaghassaei/OrigamiSimulator |
+| PackCAD | Folding simulation | https://packcad.com/ |
+| Shapely | Python geometry | pip install shapely |
+| rigid-origami gym | Reference gym env | https://github.com/belalugaX/rigid-origami |
+### Papers to Cite
+- OrigamiSpace: https://arxiv.org/abs/2511.18450
+- GamiBench: https://arxiv.org/abs/2512.22207
+- SpatialThinker: https://arxiv.org/abs/2511.07403
+- Automating Rigid Origami Design: https://arxiv.org/abs/2211.13219
+- FOLD format spec: https://github.com/edemaine/fold/blob/main/doc/spec.md
+---
+## Priority Build Order
+1. **Python geometry engine** — PaperState class with fold operations and FOLD export
+2. **Verifier functions** — Kawasaki, Maekawa, similarity metrics
+3. **OpenEnv wrapper** — step/reset/state API
+4. **Simple targets** — Hand-create 5-10 Level 1-2 targets as .fold files
+5. **Training script** — Wire up Unsloth GRPO with reward function
+6. **Run training** — Even on small model, get reward curves
+7. **Three.js visualizer** — For demo only, not in training loop
+8. **Before/after demo** — Show base model vs trained model outputs
+9. **Polish presentation narrative**
+---
+## Narrative for Judges
+**The story arc:**
+1. "LLMs are great at text but terrible at spatial reasoning"
+2. "Origami is the perfect testbed — it's sequential, physical, and verifiable"
+3. "NeurIPS 2025 showed even GPT-5 fails at origami benchmarks, but nobody built a TRAINING environment"
+4. "We built OrigamiRL — the first multi-turn RL environment for origami instruction generation"
+5. "Our rewards come from math theorems, not vibes — Kawasaki's theorem is our unit test"
+6. "Watch the model go from generating paper-tearing nonsense to valid fold sequences"
+7. "This generalizes to any domain where LLMs need to output structured physical instructions"

engine/fold_engine.py DELETED Viewed

@@ -1,207 +0,0 @@
-"""
-Fold execution engine.
-Applies fold operations (valley / mountain) to a Paper object using
-Rodrigues' rotation formula, face splitting, and layer tracking.
-"""
-from __future__ import annotations
-import math
-from typing import Callable
-import numpy as np
-from .paper import Paper
-# ────────────────────────────────────────────────────────────────────
-# Rodrigues' rotation
-# ────────────────────────────────────────────────────────────────────
-def _rodrigues_rotate(
-    points: np.ndarray,
-    axis_point: np.ndarray,
-    axis_dir: np.ndarray,
-    angle_rad: float,
-) -> np.ndarray:
-    """Rotate *points* (N, 3) around an axis defined by a point and direction
-    using Rodrigues' rotation formula.  Returns rotated points (N, 3)."""
-    k = axis_dir / (np.linalg.norm(axis_dir) + 1e-30)
-    translated = points - axis_point
-    cos_a = math.cos(angle_rad)
-    sin_a = math.sin(angle_rad)
-    dot_term = np.dot(translated, k).reshape(-1, 1) * k  # (N,1)*(3,) broadcast
-    rotated = (
-        translated * cos_a
-        + np.cross(k, translated) * sin_a
-        + dot_term * (1.0 - cos_a)
-    )
-    return rotated + axis_point
-# ────────────────────────────────────────────────────────────────────
-# Single fold
-# ────────────────────────────────────────────────────────────────────
-def apply_fold(
-    paper: Paper,
-    fold_dict: dict,
-) -> tuple[Paper, str | None]:
-    """Apply a single fold to *paper* and return ``(new_paper, error_or_None)``.
-    *fold_dict* has the form::
-        {
-            "type": "valley" | "mountain",
-            "line": {"start": [x, y], "end": [x, y]},
-            "angle": 0-180,
-        }
-    Steps:
-      1. Validate inputs.
-      2. Split faces along the fold line.
-      3. Determine vertices to rotate (one side of fold line).
-      4. Rodrigues' rotation of those vertices.
-      5. Update edge assignments for new fold-line edges.
-      6. Update fold angles.
-      7. Update layer tracking.
-    """
-    # ── 0. parse & validate ─────────────────────────────────────────
-    fold_type = fold_dict.get("type", "valley")
-    line = fold_dict.get("line", {})
-    angle_deg = fold_dict.get("angle", 180)
-    if fold_type not in ("valley", "mountain"):
-        return paper, f"Unknown fold type: {fold_type}"
-    try:
-        start_2d = np.array(line["start"], dtype=np.float64)[:2]
-        end_2d = np.array(line["end"], dtype=np.float64)[:2]
-    except (KeyError, TypeError, IndexError) as exc:
-        return paper, f"Invalid fold line: {exc}"
-    if np.linalg.norm(end_2d - start_2d) < 1e-12:
-        return paper, "Fold line has zero length"
-    if not (0 < angle_deg <= 180):
-        return paper, f"Angle must be in (0, 180], got {angle_deg}"
-    # ── 1. deep copy so the original is untouched ───────────────────
-    new_paper = paper.copy()
-    # ── 2. split faces along fold line ──────────────────────────────
-    try:
-        fold_edge_ids = new_paper.split_faces_along_line(start_2d, end_2d)
-    except Exception as exc:
-        return paper, f"Face split failed: {exc}"
-    # ── 3. determine vertices to rotate ─────────────────────────────
-    rotate_ids = new_paper.get_vertices_on_side(start_2d, end_2d, "positive")
-    if not rotate_ids:
-        # Try the other side — maybe the fold line is at the boundary
-        rotate_ids = new_paper.get_vertices_on_side(start_2d, end_2d, "negative")
-        if not rotate_ids:
-            return paper, "No vertices to rotate — fold line may not intersect paper"
-    # ── 4. Rodrigues' rotation ──────────────────────────────────────
-    sign = 1.0 if fold_type == "valley" else -1.0
-    angle_rad = sign * math.radians(angle_deg)
-    axis_point = np.array([start_2d[0], start_2d[1], 0.0])
-    axis_dir = np.array([end_2d[0] - start_2d[0], end_2d[1] - start_2d[1], 0.0])
-    pts = new_paper.vertices[rotate_ids]
-    rotated = _rodrigues_rotate(pts, axis_point, axis_dir, angle_rad)
-    new_paper.vertices[rotate_ids] = rotated
-    # ── 5. update edge assignments ──────────────────────────────────
-    assignment = "V" if fold_type == "valley" else "M"
-    for eidx in fold_edge_ids:
-        if eidx < len(new_paper.assignments):
-            new_paper.assignments[eidx] = assignment
-    # ── 6. update fold angles ───────────────────────────────────────
-    for eidx in fold_edge_ids:
-        if eidx < len(new_paper.fold_angles):
-            new_paper.fold_angles[eidx] = angle_deg * sign
-    # ── 7. update layer tracking ────────────────────────────────────
-    # For each pair of faces on opposite sides of the fold line, record
-    # layer ordering.  Simple heuristic: faces that were rotated are now
-    # on top (sign +1) of faces that stayed put.
-    rotated_set = set(rotate_ids)
-    def _face_side(face_verts: list[int]) -> str:
-        """Classify a face as 'rotated', 'fixed', or 'mixed'."""
-        r_count = sum(1 for v in face_verts if v in rotated_set)
-        if r_count == len(face_verts):
-            return "rotated"
-        if r_count == 0:
-            return "fixed"
-        return "mixed"
-    face_sides = [_face_side(f) for f in new_paper.faces]
-    for i in range(len(new_paper.faces)):
-        for j in range(i + 1, len(new_paper.faces)):
-            if face_sides[i] == "rotated" and face_sides[j] == "fixed":
-                new_paper.face_orders.append((i, j, 1))
-            elif face_sides[i] == "fixed" and face_sides[j] == "rotated":
-                new_paper.face_orders.append((j, i, 1))
-    return new_paper, None
-# ────────────────────────────────────────────────────────────────────
-# Strategy executor (matches mock_env.execute_fold_strategy signature)
-# ────────────────────────────────────────────────────────────────────
-def execute_fold_strategy(
-    strategy_fn: Callable,
-    paper: Paper,
-    max_folds: int = 20,
-) -> tuple[Paper, list[dict], str | None]:
-    """Execute a ``fold_strategy`` function against the real physics engine.
-    Signature matches ``mock_env.execute_fold_strategy`` so the trainer
-    reward functions can swap engines transparently.
-    Parameters
-    ----------
-    strategy_fn : callable
-        ``strategy_fn(paper_state_dict) -> list[dict]``
-    paper : Paper
-        The initial paper state.
-    max_folds : int
-        Maximum number of folds to apply.
-    Returns
-    -------
-    (final_paper, applied_folds, error_or_None)
-    """
-    state_dict = paper.to_dict()
-    try:
-        folds = strategy_fn(state_dict)
-    except Exception as exc:
-        return paper, [], f"Strategy function raised: {exc}"
-    if not isinstance(folds, list):
-        return paper, [], "Strategy must return a list of fold dicts"
-    applied: list[dict] = []
-    current = paper
-    for i, fold in enumerate(folds):
-        if i >= max_folds:
-            break
-        if not isinstance(fold, dict):
-            return current, applied, f"Fold {i} is not a dict"
-        current, error = apply_fold(current, fold)
-        if error:
-            return current, applied, f"Fold {i} failed: {error}"
-        applied.append(fold)
-    return current, applied, None

engine/materials.py DELETED Viewed

@@ -1,79 +0,0 @@
-"""
-Material definitions for origami simulation.
-Provides dataclass-based material properties and preset materials
-for paper, mylar, aluminum, and nitinol.
-"""
-from dataclasses import dataclass
-@dataclass
-class Material:
-    name: str
-    thickness_mm: float       # mm
-    youngs_modulus_gpa: float  # GPa
-    max_strain: float          # fraction (e.g. 0.03 = 3%)
-    poissons_ratio: float = 0.3  # dimensionless
-    @property
-    def thickness_m(self) -> float:
-        """Thickness in meters."""
-        return self.thickness_mm / 1000.0
-    @property
-    def youngs_modulus_pa(self) -> float:
-        """Young's modulus in Pascals."""
-        return self.youngs_modulus_gpa * 1e9
-# ── Preset materials ────────────────────────────────────────────────
-MATERIAL_PRESETS: dict[str, Material] = {
-    "paper": Material(
-        name="paper",
-        thickness_mm=0.1,
-        youngs_modulus_gpa=2.0,
-        max_strain=0.03,
-        poissons_ratio=0.3,
-    ),
-    "mylar": Material(
-        name="mylar",
-        thickness_mm=0.05,
-        youngs_modulus_gpa=4.0,
-        max_strain=0.03,
-        poissons_ratio=0.38,
-    ),
-    "aluminum": Material(
-        name="aluminum",
-        thickness_mm=0.1,
-        youngs_modulus_gpa=69.0,
-        max_strain=0.01,
-        poissons_ratio=0.33,
-    ),
-    "nitinol": Material(
-        name="nitinol",
-        thickness_mm=0.1,
-        youngs_modulus_gpa=75.0,
-        max_strain=0.08,
-        poissons_ratio=0.33,
-    ),
-}
-def get_material(name: str) -> Material:
-    """Return a copy of a preset material by name.
-    Raises KeyError if name is not in MATERIAL_PRESETS.
-    """
-    if name not in MATERIAL_PRESETS:
-        available = ", ".join(sorted(MATERIAL_PRESETS))
-        raise KeyError(f"Unknown material '{name}'. Available: {available}")
-    preset = MATERIAL_PRESETS[name]
-    return Material(
-        name=preset.name,
-        thickness_mm=preset.thickness_mm,
-        youngs_modulus_gpa=preset.youngs_modulus_gpa,
-        max_strain=preset.max_strain,
-        poissons_ratio=preset.poissons_ratio,
-    )

engine/metrics.py DELETED Viewed

@@ -1,104 +0,0 @@
-"""
-Quality metrics for folded origami.
-Computes bounding box, deployment ratio, fold count, and aggregated
-metric dictionaries for the trainer reward functions.
-"""
-from __future__ import annotations
-import numpy as np
-from .paper import Paper
-def compute_bounding_box(paper: Paper) -> np.ndarray:
-    """Axis-aligned bounding-box dimensions (dx, dy, dz).
-    Returns shape (3,) array.  Minimum z-thickness accounts for
-    material thickness times estimated layer count.
-    """
-    if len(paper.vertices) == 0:
-        return np.zeros(3)
-    ptp = np.ptp(paper.vertices, axis=0)
-    ptp = np.where(np.abs(ptp) < 1e-12, 0.0, ptp)
-    # Minimum z from material thickness * layers
-    t = paper.material.thickness_mm / 1000.0
-    ptp[2] = max(ptp[2], t * paper.num_layers)
-    return ptp
-def compute_deployment_ratio(paper: Paper) -> float:
-    """Ratio of folded XY footprint area to original sheet area.
-    A fully flat unfolded sheet has ratio 1.0; a tightly folded sheet
-    approaches 0.0.
-    """
-    if paper.original_area <= 0:
-        return 1.0
-    bb = compute_bounding_box(paper)
-    folded_area = bb[0] * bb[1]
-    ratio = folded_area / paper.original_area
-    return float(np.clip(ratio, 0.0, 1.0))
-def compute_fold_count(paper: Paper) -> int:
-    """Number of mountain (M) and valley (V) edges."""
-    return sum(1 for a in paper.assignments if a in ("M", "V"))
-def compute_compactness(paper: Paper) -> float:
-    """1 - deployment_ratio.  Higher is more compact."""
-    return 1.0 - compute_deployment_ratio(paper)
-def compute_volume(paper: Paper) -> float:
-    """Bounding-box volume in cubic meters."""
-    bb = compute_bounding_box(paper)
-    return float(bb[0] * bb[1] * bb[2])
-def compute_metrics(paper: Paper, original_paper: Paper | None = None) -> dict:
-    """Compute all quality metrics and return as a dict.
-    Parameters
-    ----------
-    paper : Paper
-        The current (folded) paper state.
-    original_paper : Paper or None
-        The original (unfolded) paper, used for strain comparison.
-        If None, strain is computed against the current paper's rest lengths.
-    Returns
-    -------
-    dict with keys:
-        bounding_box, deployment_ratio, fold_count, compactness,
-        volume, max_strain, mean_strain, num_vertices, num_faces,
-        num_layers.
-    """
-    from .physics import compute_strain  # local import to avoid circular
-    bb = compute_bounding_box(paper)
-    strain = compute_strain(paper)
-    return {
-        "bounding_box": {
-            "x": float(bb[0]),
-            "y": float(bb[1]),
-            "z": float(bb[2]),
-        },
-        "deployment_ratio": compute_deployment_ratio(paper),
-        "fold_count": compute_fold_count(paper),
-        "compactness": compute_compactness(paper),
-        "volume": compute_volume(paper),
-        "max_strain": float(np.max(strain)) if len(strain) > 0 else 0.0,
-        "mean_strain": float(np.mean(strain)) if len(strain) > 0 else 0.0,
-        "num_vertices": len(paper.vertices),
-        "num_faces": len(paper.faces),
-        "num_layers": paper.num_layers,
-    }

engine/paper.py DELETED Viewed

@@ -1,488 +0,0 @@
-"""
-Paper — the core geometric data structure for origami simulation.
-Stores vertices, edges, faces, fold assignments, fold angles, layer ordering,
-and material.  Supports FOLD-format serialization and the face-splitting
-operation needed by the fold engine.
-"""
-from __future__ import annotations
-import copy
-import json
-from dataclasses import dataclass, field
-from typing import Any
-import numpy as np
-from .materials import Material, get_material
-# ────────────────────────────────────────────────────────────────────
-# Helper: 2-D line-segment intersection
-# ────────────────────────────────────────────────────────────────────
-def _seg_seg_intersect_2d(
-    p1: np.ndarray, p2: np.ndarray,
-    p3: np.ndarray, p4: np.ndarray,
-    eps: float = 1e-10,
-) -> np.ndarray | None:
-    """Return the intersection point of segments (p1-p2) and (p3-p4) in 2-D,
-    or None if they do not intersect.  Points that lie on the segment
-    endpoints are considered intersections (within tolerance *eps*).
-    All inputs are shape (2,).
-    """
-    d1 = p2 - p1
-    d2 = p4 - p3
-    denom = d1[0] * d2[1] - d1[1] * d2[0]
-    if abs(denom) < eps:
-        return None  # parallel / collinear
-    dp = p3 - p1
-    t = (dp[0] * d2[1] - dp[1] * d2[0]) / denom
-    u = (dp[0] * d1[1] - dp[1] * d1[0]) / denom
-    if -eps <= t <= 1.0 + eps and -eps <= u <= 1.0 + eps:
-        return p1 + np.clip(t, 0.0, 1.0) * d1
-    return None
-# ────────────────────────────────────────────────────────────────────
-# Paper dataclass
-# ────────────────────────────────────────────────────────────────────
-@dataclass
-class Paper:
-    """Origami sheet state.
-    Attributes
-    ----------
-    vertices : np.ndarray, shape (N, 3)
-        Vertex positions in 3-D.
-    edges : np.ndarray, shape (E, 2), dtype int
-        Each row is (v_start, v_end).
-    faces : list[list[int]]
-        Each face is an ordered list of vertex indices (CCW winding).
-    assignments : list[str]
-        Per-edge assignment: 'M' (mountain), 'V' (valley), 'B' (boundary),
-        'F' (flat / unfolded), 'U' (unassigned).
-    fold_angles : np.ndarray, shape (E,)
-        Current fold angle (degrees) per edge.
-    face_orders : list[tuple[int, int, int]]
-        Layer ordering triples (f_i, f_j, +1/-1) meaning f_i is above/below f_j.
-    material : Material
-        The sheet material.
-    rest_lengths : np.ndarray, shape (E,)
-        Original (unfolded) edge lengths — used for strain computation.
-    original_area : float
-        Area of the sheet before any folds.
-    """
-    vertices: np.ndarray
-    edges: np.ndarray
-    faces: list[list[int]]
-    assignments: list[str]
-    fold_angles: np.ndarray
-    face_orders: list[tuple[int, int, int]] = field(default_factory=list)
-    material: Material = field(default_factory=lambda: get_material("paper"))
-    rest_lengths: np.ndarray = field(default_factory=lambda: np.empty(0))
-    original_area: float = 0.0
-    # ── constructors ────────────────────────────────────────────────
-    @staticmethod
-    def create_flat_sheet(
-        width: float = 1.0,
-        height: float = 1.0,
-        material: Material | None = None,
-    ) -> "Paper":
-        """Create a flat rectangular sheet with 4 vertices, 5 edges
-        (including one diagonal), and 2 triangular faces."""
-        mat = material if material is not None else get_material("paper")
-        verts = np.array([
-            [0.0, 0.0, 0.0],
-            [width, 0.0, 0.0],
-            [width, height, 0.0],
-            [0.0, height, 0.0],
-        ], dtype=np.float64)
-        edges = np.array([
-            [0, 1],  # bottom
-            [1, 2],  # right
-            [2, 3],  # top
-            [3, 0],  # left
-            [0, 2],  # diagonal
-        ], dtype=np.int64)
-        faces: list[list[int]] = [[0, 1, 2], [0, 2, 3]]
-        assignments = ["B", "B", "B", "B", "F"]
-        fold_angles = np.zeros(len(edges), dtype=np.float64)
-        rest_lengths = np.array(
-            [np.linalg.norm(verts[e[1]] - verts[e[0]]) for e in edges],
-            dtype=np.float64,
-        )
-        return Paper(
-            vertices=verts,
-            edges=edges,
-            faces=faces,
-            assignments=assignments,
-            fold_angles=fold_angles,
-            material=mat,
-            rest_lengths=rest_lengths,
-            original_area=width * height,
-        )
-    # ── dict / prompt serialization (matches mock_env.PaperState.to_dict) ──
-    def to_dict(self) -> dict:
-        """Return a simplified dict suitable for LLM prompts.
-        The format matches ``mock_env.PaperState.to_dict()`` so that the
-        trainer reward functions work with either engine.
-        """
-        bb = self.bounding_box
-        return {
-            "width": float(bb[0]),
-            "height": float(bb[1]),
-            "material": {
-                "name": self.material.name,
-                "thickness_mm": self.material.thickness_mm,
-                "youngs_modulus_gpa": self.material.youngs_modulus_gpa,
-            },
-            "vertices": self.vertices.tolist(),
-            "edges": self.edges.tolist(),
-            "assignments": list(self.assignments),
-            "fold_angles": self.fold_angles.tolist(),
-            "num_layers_at_center": self.num_layers,
-            "bounding_box": {
-                "x": float(bb[0]),
-                "y": float(bb[1]),
-                "z": float(bb[2]),
-            },
-        }
-    # ── FOLD format serialization ───────────────────────────────────
-    def to_fold_json(self) -> str:
-        """Serialize to FOLD JSON format (v1.1 subset)."""
-        fold = {
-            "file_spec": 1.1,
-            "file_creator": "optigami",
-            "file_classes": ["singleModel"],
-            "frame_classes": ["foldedForm"],
-            "vertices_coords": self.vertices.tolist(),
-            "edges_vertices": self.edges.tolist(),
-            "edges_assignment": self.assignments,
-            "edges_foldAngle": self.fold_angles.tolist(),
-            "faces_vertices": self.faces,
-            "faceOrders": [list(fo) for fo in self.face_orders],
-        }
-        return json.dumps(fold, indent=2)
-    @staticmethod
-    def from_fold_json(data: str | dict, material: Material | None = None) -> "Paper":
-        """Deserialize from FOLD JSON format."""
-        if isinstance(data, str):
-            data = json.loads(data)
-        verts = np.array(data["vertices_coords"], dtype=np.float64)
-        edges = np.array(data["edges_vertices"], dtype=np.int64)
-        faces = data.get("faces_vertices", [])
-        assignments = data.get("edges_assignment", ["U"] * len(edges))
-        fold_angles = np.array(
-            data.get("edges_foldAngle", [0.0] * len(edges)),
-            dtype=np.float64,
-        )
-        face_orders = [tuple(fo) for fo in data.get("faceOrders", [])]
-        rest_lengths = np.array(
-            [np.linalg.norm(verts[e[1]] - verts[e[0]]) for e in edges],
-            dtype=np.float64,
-        )
-        mat = material if material is not None else get_material("paper")
-        # Approximate original area from convex hull of initial XY footprint
-        try:
-            from scipy.spatial import ConvexHull
-            hull = ConvexHull(verts[:, :2])
-            area = hull.volume  # 2-D ConvexHull.volume is area
-        except Exception:
-            # Fallback: bounding-box area from XY coordinates
-            if len(verts) >= 2:
-                ptp = np.ptp(verts[:, :2], axis=0)
-                area = float(ptp[0] * ptp[1])
-            else:
-                area = 0.0
-        return Paper(
-            vertices=verts,
-            edges=edges,
-            faces=faces,
-            assignments=assignments,
-            fold_angles=fold_angles,
-            face_orders=face_orders,
-            material=mat,
-            rest_lengths=rest_lengths,
-            original_area=area,
-        )
-    # ── computed properties ─────────────────────────────────────────
-    @property
-    def bounding_box(self) -> np.ndarray:
-        """Axis-aligned bounding-box dimensions (dx, dy, dz)."""
-        if len(self.vertices) == 0:
-            return np.zeros(3)
-        ptp = np.ptp(self.vertices, axis=0)
-        ptp = np.where(np.abs(ptp) < 1e-12, 0.0, ptp)
-        # Ensure minimum z height from material thickness * layers
-        t = self.material.thickness_mm / 1000.0
-        ptp[2] = max(ptp[2], t * self.num_layers)
-        return ptp
-    @property
-    def num_layers(self) -> int:
-        """Estimate layer count from face-order triples.
-        Falls back to 1 + number of M/V edges as a simple heuristic when
-        face_orders is empty.
-        """
-        if self.face_orders:
-            face_ids = set()
-            for fo in self.face_orders:
-                face_ids.add(fo[0])
-                face_ids.add(fo[1])
-            return max(len(face_ids), 1)
-        # Heuristic: each fold adds one layer
-        mv_count = sum(1 for a in self.assignments if a in ("M", "V"))
-        return 1 + mv_count
-    # ── topology helpers ────────────────────────────────────────────
-    def _find_or_add_vertex(self, point_3d: np.ndarray, tol: float = 1e-8) -> int:
-        """Return index of an existing vertex close to *point_3d*, or add a
-        new vertex and return its index."""
-        for i, v in enumerate(self.vertices):
-            if np.linalg.norm(v - point_3d) < tol:
-                return i
-        idx = len(self.vertices)
-        self.vertices = np.vstack([self.vertices, point_3d.reshape(1, 3)])
-        return idx
-    def _find_or_add_edge(self, v1: int, v2: int) -> int:
-        """Return index of edge (v1,v2) or (v2,v1), or add a new edge and
-        return its index.  New edges get assignment 'F' and fold-angle 0."""
-        for i, e in enumerate(self.edges):
-            if (e[0] == v1 and e[1] == v2) or (e[0] == v2 and e[1] == v1):
-                return i
-        idx = len(self.edges)
-        self.edges = np.vstack([self.edges, np.array([[v1, v2]], dtype=np.int64)])
-        self.assignments.append("F")
-        self.fold_angles = np.append(self.fold_angles, 0.0)
-        # Rest length for the new edge
-        rl = np.linalg.norm(self.vertices[v1] - self.vertices[v2])
-        self.rest_lengths = np.append(self.rest_lengths, rl)
-        return idx
-    # ── face splitting ──────────────────────────────────────────────
-    def split_faces_along_line(
-        self,
-        start_2d: np.ndarray | list,
-        end_2d: np.ndarray | list,
-    ) -> list[int]:
-        """Split every face that the 2-D line (start_2d -> end_2d) crosses.
-        The line is infinite for intersection purposes (we test each face
-        edge-segment against the full fold-line extent clipped to the paper).
-        Returns a list of edge indices that lie *on* the fold line (i.e. the
-        newly created edges along the fold path).
-        This mutates ``self`` in-place (vertices, edges, faces, assignments,
-        fold_angles, rest_lengths are updated).
-        """
-        start_2d = np.asarray(start_2d, dtype=np.float64)
-        end_2d = np.asarray(end_2d, dtype=np.float64)
-        fold_edge_indices: list[int] = []
-        new_faces: list[list[int]] = []
-        faces_to_process = list(range(len(self.faces)))
-        for fi in faces_to_process:
-            face = self.faces[fi]
-            n = len(face)
-            # Gather intersection points along the face boundary
-            hits: list[tuple[int, np.ndarray]] = []  # (local_edge_index, point_2d)
-            for k in range(n):
-                v_a = face[k]
-                v_b = face[(k + 1) % n]
-                pa = self.vertices[v_a][:2]
-                pb = self.vertices[v_b][:2]
-                pt = _seg_seg_intersect_2d(start_2d, end_2d, pa, pb)
-                if pt is not None:
-                    hits.append((k, pt))
-            # Deduplicate hits that are at the same location (e.g. hitting a vertex)
-            if len(hits) >= 2:
-                unique_hits: list[tuple[int, np.ndarray]] = [hits[0]]
-                for h in hits[1:]:
-                    is_dup = False
-                    for uh in unique_hits:
-                        if np.linalg.norm(h[1] - uh[1]) < 1e-8:
-                            is_dup = True
-                            break
-                    if not is_dup:
-                        unique_hits.append(h)
-                hits = unique_hits
-            if len(hits) < 2:
-                # Line does not fully cross this face — keep face as-is
-                new_faces.append(face)
-                continue
-            # We only handle the first two intersection points (one chord across face)
-            hit_a_edge_idx, hit_a_pt = hits[0]
-            hit_b_edge_idx, hit_b_pt = hits[1]
-            # Create / find 3-D vertices at intersection points (z=0 for flat, interpolated otherwise)
-            def _interp_z(pt2d: np.ndarray, edge_local: int) -> np.ndarray:
-                """Interpolate z from the edge endpoints."""
-                v_a = face[edge_local]
-                v_b = face[(edge_local + 1) % n]
-                pa = self.vertices[v_a]
-                pb = self.vertices[v_b]
-                seg = pb[:2] - pa[:2]
-                seg_len = np.linalg.norm(seg)
-                if seg_len < 1e-12:
-                    return np.array([pt2d[0], pt2d[1], pa[2]])
-                t = np.linalg.norm(pt2d - pa[:2]) / seg_len
-                t = np.clip(t, 0.0, 1.0)
-                z = pa[2] + t * (pb[2] - pa[2])
-                return np.array([pt2d[0], pt2d[1], z])
-            pt_a_3d = _interp_z(hit_a_pt, hit_a_edge_idx)
-            pt_b_3d = _interp_z(hit_b_pt, hit_b_edge_idx)
-            idx_a = self._find_or_add_vertex(pt_a_3d)
-            idx_b = self._find_or_add_vertex(pt_b_3d)
-            if idx_a == idx_b:
-                new_faces.append(face)
-                continue
-            # Add the fold-line edge between the two intersection points
-            fold_eidx = self._find_or_add_edge(idx_a, idx_b)
-            fold_edge_indices.append(fold_eidx)
-            # ── Split the face into two sub-faces ──
-            # Walk around the face vertices, inserting idx_a and idx_b at the
-            # appropriate positions, then split into two loops.
-            ordered_verts = list(face)
-            # Insert intersection vertices into the vertex ring if not already present
-            def _insert_after(ring: list[int], after_local: int, vid: int) -> list[int]:
-                """Insert *vid* after position *after_local* if it is not already
-                adjacent in the ring at that position."""
-                pos = after_local + 1
-                if ring[after_local % len(ring)] == vid:
-                    return ring
-                if ring[pos % len(ring)] == vid:
-                    return ring
-                return ring[:pos] + [vid] + ring[pos:]
-            # Determine insertion order — always insert the one with the
-            # larger local-edge index first so that the earlier index stays valid.
-            if hit_a_edge_idx <= hit_b_edge_idx:
-                ordered_verts = _insert_after(ordered_verts, hit_b_edge_idx, idx_b)
-                # Recompute hit_a_edge_idx offset if idx_b was inserted before it
-                # (it shouldn't be, since hit_b >= hit_a, but guard anyway)
-                a_pos = hit_a_edge_idx
-                ordered_verts = _insert_after(ordered_verts, a_pos, idx_a)
-            else:
-                ordered_verts = _insert_after(ordered_verts, hit_a_edge_idx, idx_a)
-                ordered_verts = _insert_after(ordered_verts, hit_b_edge_idx, idx_b)
-            # Now split the ring at idx_a and idx_b
-            try:
-                pos_a = ordered_verts.index(idx_a)
-                pos_b = ordered_verts.index(idx_b)
-            except ValueError:
-                new_faces.append(face)
-                continue
-            if pos_a > pos_b:
-                pos_a, pos_b = pos_b, pos_a
-            loop1 = ordered_verts[pos_a: pos_b + 1]
-            loop2 = ordered_verts[pos_b:] + ordered_verts[: pos_a + 1]
-            # Only keep faces with >= 3 unique vertices
-            for loop in (loop1, loop2):
-                unique = list(dict.fromkeys(loop))  # preserve order, dedupe
-                if len(unique) >= 3:
-                    new_faces.append(unique)
-                    # Ensure all edges of this new face exist
-                    for k in range(len(unique)):
-                        self._find_or_add_edge(unique[k], unique[(k + 1) % len(unique)])
-        self.faces = new_faces
-        return fold_edge_indices
-    # ── vertex side test ────────────────────────────────────────────
-    def get_vertices_on_side(
-        self,
-        line_start: np.ndarray | list,
-        line_end: np.ndarray | list,
-        side: str = "positive",
-    ) -> list[int]:
-        """Return indices of vertices on one side of a 2-D line.
-        *side* can be ``"positive"`` or ``"negative"``.  The positive side is
-        defined by the left-hand normal of (line_end - line_start).
-        """
-        ls = np.asarray(line_start, dtype=np.float64)[:2]
-        le = np.asarray(line_end, dtype=np.float64)[:2]
-        d = le - ls
-        normal = np.array([-d[1], d[0]])
-        indices: list[int] = []
-        for i, v in enumerate(self.vertices):
-            dot = np.dot(v[:2] - ls, normal)
-            if side == "positive" and dot > 1e-9:
-                indices.append(i)
-            elif side == "negative" and dot < -1e-9:
-                indices.append(i)
-        return indices
-    # ── deep copy ───────────────────────────────────────────────────
-    def copy(self) -> "Paper":
-        """Return an independent deep copy."""
-        return Paper(
-            vertices=self.vertices.copy(),
-            edges=self.edges.copy(),
-            faces=copy.deepcopy(self.faces),
-            assignments=list(self.assignments),
-            fold_angles=self.fold_angles.copy(),
-            face_orders=list(self.face_orders),
-            material=Material(
-                name=self.material.name,
-                thickness_mm=self.material.thickness_mm,
-                youngs_modulus_gpa=self.material.youngs_modulus_gpa,
-                max_strain=self.material.max_strain,
-                poissons_ratio=self.material.poissons_ratio,
-            ),
-            rest_lengths=self.rest_lengths.copy(),
-            original_area=self.original_area,
-        )

engine/physics.py DELETED Viewed

@@ -1,257 +0,0 @@
-"""
-Bar-and-hinge physics model.
-Three energy components:
-  E_total = E_bar + E_facet + E_fold
-Stiffness parameters are derived from the material properties.
-"""
-from __future__ import annotations
-from dataclasses import dataclass
-import numpy as np
-from .paper import Paper
-# ────────────────────────────────────────────────────────────────────
-# Stiffness
-# ────────────────────────────────────────────────────────────────────
-@dataclass
-class StiffnessParams:
-    """Stiffness values derived from material properties."""
-    k_axial: np.ndarray   # per-edge axial stiffness  (E,)
-    k_facet: float         # facet (panel bending) stiffness
-    k_fold: float          # fold (crease torsion) stiffness
-def compute_stiffness(paper: Paper) -> StiffnessParams:
-    """Derive stiffness parameters from the paper's material and geometry.
-    k_axial = E * t * w / L0   (per edge, w ≈ average of adjacent edge lengths)
-    k_facet = E * t^3 / (12 * (1 - nu^2))
-    k_fold  = 0.1 * k_facet    (crease torsional stiffness, empirical fraction)
-    """
-    mat = paper.material
-    E = mat.youngs_modulus_pa  # Pa
-    t = mat.thickness_m        # m
-    nu = mat.poissons_ratio
-    rest = paper.rest_lengths
-    # Guard against zero rest lengths
-    safe_rest = np.where(rest > 1e-15, rest, 1e-15)
-    # Approximate edge width as the average rest length (simple heuristic)
-    w = np.mean(safe_rest) if len(safe_rest) > 0 else 1e-3
-    k_axial = E * t * w / safe_rest  # (E,)
-    k_facet = E * t ** 3 / (12.0 * (1.0 - nu ** 2))
-    # Crease torsional stiffness — a fraction of facet stiffness
-    k_fold = 0.1 * k_facet
-    return StiffnessParams(k_axial=k_axial, k_facet=k_facet, k_fold=k_fold)
-# ────────────────────────────────────────────────────────────────────
-# Energy components
-# ────────────────────────────────────────────────────────────────────
-def compute_bar_energy(paper: Paper) -> float:
-    """E_bar = sum (1/2) * k_axial * (L - L0)^2
-    Measures stretching / compression of edges relative to rest lengths.
-    """
-    if len(paper.edges) == 0:
-        return 0.0
-    verts = paper.vertices
-    edges = paper.edges
-    current_lengths = np.array([
-        np.linalg.norm(verts[e[1]] - verts[e[0]]) for e in edges
-    ])
-    stiff = compute_stiffness(paper)
-    delta = current_lengths - paper.rest_lengths
-    energy = 0.5 * np.sum(stiff.k_axial * delta ** 2)
-    return float(energy)
-def compute_facet_energy(paper: Paper) -> float:
-    """E_facet = sum (1/2) * k_facet * l * (theta - pi)^2
-    Measures bending of facet panels away from flat (pi).
-    *l* is the edge length (hinge length) and *theta* is the dihedral angle
-    across the edge between two adjacent faces.  For edges that are not
-    shared by two faces we skip them.
-    """
-    if len(paper.edges) == 0 or len(paper.faces) < 2:
-        return 0.0
-    stiff = compute_stiffness(paper)
-    verts = paper.vertices
-    edges = paper.edges
-    # Build edge → face adjacency
-    edge_faces: dict[int, list[int]] = {}
-    for fi, face in enumerate(paper.faces):
-        n = len(face)
-        for k in range(n):
-            va, vb = face[k], face[(k + 1) % n]
-            for ei, e in enumerate(edges):
-                if (e[0] == va and e[1] == vb) or (e[0] == vb and e[1] == va):
-                    edge_faces.setdefault(ei, []).append(fi)
-                    break
-    energy = 0.0
-    for ei, adj_faces in edge_faces.items():
-        if len(adj_faces) < 2:
-            continue
-        # Only consider non-fold edges (flat or boundary interior)
-        if paper.assignments[ei] in ("M", "V"):
-            continue
-        f1, f2 = adj_faces[0], adj_faces[1]
-        theta = _dihedral_angle(verts, paper.faces[f1], paper.faces[f2], edges[ei])
-        l = np.linalg.norm(verts[edges[ei][1]] - verts[edges[ei][0]])
-        energy += 0.5 * stiff.k_facet * l * (theta - np.pi) ** 2
-    return float(energy)
-def compute_fold_energy(paper: Paper) -> float:
-    """E_fold = sum (1/2) * k_fold * l * (rho - rho_target)^2
-    Measures deviation of fold creases from their target angles.
-    *rho* is the current dihedral angle across the fold edge and
-    *rho_target* comes from ``fold_angles``.
-    """
-    if len(paper.edges) == 0:
-        return 0.0
-    stiff = compute_stiffness(paper)
-    verts = paper.vertices
-    edges = paper.edges
-    # Build edge → face adjacency
-    edge_faces: dict[int, list[int]] = {}
-    for fi, face in enumerate(paper.faces):
-        n = len(face)
-        for k in range(n):
-            va, vb = face[k], face[(k + 1) % n]
-            for ei, e in enumerate(edges):
-                if (e[0] == va and e[1] == vb) or (e[0] == vb and e[1] == va):
-                    edge_faces.setdefault(ei, []).append(fi)
-                    break
-    energy = 0.0
-    for ei in range(len(edges)):
-        if paper.assignments[ei] not in ("M", "V"):
-            continue
-        if ei not in edge_faces or len(edge_faces[ei]) < 2:
-            continue
-        f1, f2 = edge_faces[ei][0], edge_faces[ei][1]
-        rho = _dihedral_angle(verts, paper.faces[f1], paper.faces[f2], edges[ei])
-        rho_target = np.radians(paper.fold_angles[ei])  # fold_angles stored in degrees
-        l = np.linalg.norm(verts[edges[ei][1]] - verts[edges[ei][0]])
-        energy += 0.5 * stiff.k_fold * l * (rho - rho_target) ** 2
-    return float(energy)
-def compute_total_energy(paper: Paper) -> float:
-    """E_total = E_bar + E_facet + E_fold."""
-    return compute_bar_energy(paper) + compute_facet_energy(paper) + compute_fold_energy(paper)
-# ────────────────────────────────────────────────────────────────────
-# Strain
-# ────────────────────────────────────────────────────────────────────
-def compute_strain(paper: Paper) -> np.ndarray:
-    """Per-vertex Cauchy strain: average fractional edge-length deviation.
-    Returns shape (N,) array of non-negative strain values.
-    """
-    n_verts = len(paper.vertices)
-    if n_verts == 0:
-        return np.empty(0)
-    verts = paper.vertices
-    edges = paper.edges
-    rest = paper.rest_lengths
-    # Build vertex → edge adjacency
-    vert_edges: dict[int, list[int]] = {}
-    for ei, e in enumerate(edges):
-        vert_edges.setdefault(int(e[0]), []).append(ei)
-        vert_edges.setdefault(int(e[1]), []).append(ei)
-    strain = np.zeros(n_verts, dtype=np.float64)
-    for vi in range(n_verts):
-        adj = vert_edges.get(vi, [])
-        if not adj:
-            continue
-        devs = []
-        for ei in adj:
-            v1, v2 = edges[ei]
-            L = np.linalg.norm(verts[v1] - verts[v2])
-            L0 = rest[ei]
-            if L0 > 1e-15:
-                devs.append(abs(L - L0) / L0)
-        if devs:
-            strain[vi] = float(np.mean(devs))
-    return strain
-# ────────────────────────────────────────────────────────────────────
-# Dihedral angle helper
-# ────────────────────────────────────────────────────────────────────
-def _dihedral_angle(
-    verts: np.ndarray,
-    face1: list[int],
-    face2: list[int],
-    edge: np.ndarray,
-) -> float:
-    """Compute the dihedral angle (in radians) between two faces sharing *edge*.
-    Returns angle in [0, 2*pi).  Returns pi if normals cannot be computed.
-    """
-    n1 = _face_normal(verts, face1)
-    n2 = _face_normal(verts, face2)
-    if n1 is None or n2 is None:
-        return np.pi
-    cos_a = np.clip(np.dot(n1, n2), -1.0, 1.0)
-    angle = np.arccos(cos_a)
-    # Determine sign from edge direction
-    edge_dir = verts[edge[1]] - verts[edge[0]]
-    edge_dir = edge_dir / (np.linalg.norm(edge_dir) + 1e-30)
-    cross = np.cross(n1, n2)
-    if np.dot(cross, edge_dir) < 0:
-        angle = 2.0 * np.pi - angle
-    return float(angle)
-def _face_normal(verts: np.ndarray, face: list[int]) -> np.ndarray | None:
-    """Compute outward unit normal of a face, or None if degenerate."""
-    if len(face) < 3:
-        return None
-    v0 = verts[face[0]]
-    v1 = verts[face[1]]
-    v2 = verts[face[2]]
-    normal = np.cross(v1 - v0, v2 - v0)
-    norm = np.linalg.norm(normal)
-    if norm < 1e-15:
-        return None
-    return normal / norm

engine/validation.py DELETED Viewed

@@ -1,256 +0,0 @@
-"""
-Geometric validation for origami crease patterns.
-Implements Kawasaki's theorem, Maekawa's theorem, and triangle-triangle
-self-intersection detection.
-"""
-from __future__ import annotations
-from dataclasses import dataclass
-import numpy as np
-from .paper import Paper
-# ────────────────────────────────────────────────────────────────────
-# Result container
-# ────────────────────────────────────────────────────────────────────
-@dataclass
-class ValidationResult:
-    kawasaki_valid: bool
-    kawasaki_violation: float
-    maekawa_valid: bool
-    maekawa_violation: float
-    intersection_free: bool
-    self_intersection_count: int
-    is_valid: bool  # all checks pass
-# ────────────────────────────────────────────────────────────────────
-# Kawasaki's theorem
-# ────────────────────────────────────────────────────────────────────
-def check_kawasaki(paper: Paper) -> tuple[bool, float]:
-    """At each interior vertex, the alternating sum of sector angles equals pi.
-    Specifically, for a vertex with 2n incident creases, the sum of
-    odd-indexed sector angles equals the sum of even-indexed sector
-    angles equals pi.
-    Returns (is_valid, total_violation).  A violation of < 1e-6 is
-    considered valid.
-    """
-    verts = paper.vertices
-    edges = paper.edges
-    n_verts = len(verts)
-    # Build adjacency: vertex -> list of neighbor vertices (via edges)
-    adj: dict[int, list[int]] = {}
-    for e in edges:
-        adj.setdefault(int(e[0]), []).append(int(e[1]))
-        adj.setdefault(int(e[1]), []).append(int(e[0]))
-    # Identify boundary vertices (incident to a 'B' edge)
-    boundary_verts: set[int] = set()
-    for ei, e in enumerate(edges):
-        if paper.assignments[ei] == "B":
-            boundary_verts.add(int(e[0]))
-            boundary_verts.add(int(e[1]))
-    total_violation = 0.0
-    for vi in range(n_verts):
-        if vi in boundary_verts:
-            continue
-        neighbors = adj.get(vi, [])
-        if len(neighbors) < 2:
-            continue
-        # Sort neighbors by angle around vi (in the XY plane for flat-foldability)
-        center = verts[vi][:2]
-        angles = []
-        for ni in neighbors:
-            d = verts[ni][:2] - center
-            angles.append((np.arctan2(d[1], d[0]), ni))
-        angles.sort(key=lambda x: x[0])
-        # Sector angles
-        sector_angles = []
-        for k in range(len(angles)):
-            a1 = angles[k][0]
-            a2 = angles[(k + 1) % len(angles)][0]
-            diff = a2 - a1
-            if diff <= 0:
-                diff += 2.0 * np.pi
-            sector_angles.append(diff)
-        if len(sector_angles) < 2:
-            continue
-        # Kawasaki: alternating sums should both equal pi
-        even_sum = sum(sector_angles[i] for i in range(0, len(sector_angles), 2))
-        odd_sum = sum(sector_angles[i] for i in range(1, len(sector_angles), 2))
-        violation = abs(even_sum - odd_sum)
-        total_violation += violation
-    is_valid = total_violation < 1e-4
-    return is_valid, float(total_violation)
-# ────────────────────────────────────────────────────────────────────
-# Maekawa's theorem
-# ────────────────────────────────────────────────────────────────────
-def check_maekawa(paper: Paper) -> tuple[bool, float]:
-    """At each interior vertex, |M - V| = 2.
-    Returns (is_valid, total_violation) where violation is
-    sum of |abs(M-V) - 2| over all interior vertices.
-    """
-    edges = paper.edges
-    verts = paper.vertices
-    n_verts = len(verts)
-    # Boundary vertices
-    boundary_verts: set[int] = set()
-    for ei, e in enumerate(edges):
-        if paper.assignments[ei] == "B":
-            boundary_verts.add(int(e[0]))
-            boundary_verts.add(int(e[1]))
-    # Count M and V edges per vertex
-    m_count = [0] * n_verts
-    v_count = [0] * n_verts
-    total_mv_per_vertex = [0] * n_verts
-    for ei, e in enumerate(edges):
-        a = paper.assignments[ei]
-        if a == "M":
-            m_count[int(e[0])] += 1
-            m_count[int(e[1])] += 1
-        elif a == "V":
-            v_count[int(e[0])] += 1
-            v_count[int(e[1])] += 1
-        if a in ("M", "V"):
-            total_mv_per_vertex[int(e[0])] += 1
-            total_mv_per_vertex[int(e[1])] += 1
-    total_violation = 0.0
-    for vi in range(n_verts):
-        if vi in boundary_verts:
-            continue
-        # Only check vertices that actually have creases
-        if total_mv_per_vertex[vi] == 0:
-            continue
-        diff = abs(m_count[vi] - v_count[vi])
-        violation = abs(diff - 2)
-        total_violation += violation
-    is_valid = total_violation < 0.5  # integer theorem, so < 0.5 means exact
-    return is_valid, float(total_violation)
-# ────────────────────────────────────────────────────────────────────
-# Self-intersection detection (triangle-triangle)
-# ────────────────────────────────────────────────────────────────────
-def check_self_intersection(paper: Paper) -> tuple[bool, int]:
-    """Check for triangle-triangle intersections among the paper's faces.
-    Uses the separating-axis theorem (SAT) for triangle-triangle overlap
-    in 3-D.  Faces that share an edge or vertex are skipped.
-    Returns (is_valid, count_of_intersections).
-    """
-    verts = paper.vertices
-    faces = paper.faces
-    count = 0
-    for i in range(len(faces)):
-        for j in range(i + 1, len(faces)):
-            # Skip faces that share vertices (adjacent faces)
-            if set(faces[i]) & set(faces[j]):
-                continue
-            if _triangles_intersect(verts, faces[i], faces[j]):
-                count += 1
-    return count == 0, count
-def _triangles_intersect(
-    verts: np.ndarray,
-    face1: list[int],
-    face2: list[int],
-) -> bool:
-    """Test whether two triangular faces intersect in 3-D using
-    the separating-axis theorem (Moller's method simplified).
-    For non-triangular faces, only tests the first three vertices.
-    Returns True if the triangles intersect.
-    """
-    if len(face1) < 3 or len(face2) < 3:
-        return False
-    t1 = verts[face1[:3]]
-    t2 = verts[face2[:3]]
-    # 13 potential separating axes:
-    # - normals of each triangle (2)
-    # - cross products of edge pairs (3x3 = 9)
-    # - edges themselves don't need separate tests in 3D SAT
-    e1_edges = [t1[1] - t1[0], t1[2] - t1[1], t1[0] - t1[2]]
-    e2_edges = [t2[1] - t2[0], t2[2] - t2[1], t2[0] - t2[2]]
-    n1 = np.cross(e1_edges[0], e1_edges[1])
-    n2 = np.cross(e2_edges[0], e2_edges[1])
-    axes = [n1, n2]
-    for e1 in e1_edges:
-        for e2 in e2_edges:
-            ax = np.cross(e1, e2)
-            if np.linalg.norm(ax) > 1e-12:
-                axes.append(ax)
-    for axis in axes:
-        norm = np.linalg.norm(axis)
-        if norm < 1e-12:
-            continue
-        axis = axis / norm
-        proj1 = np.dot(t1, axis)
-        proj2 = np.dot(t2, axis)
-        min1, max1 = proj1.min(), proj1.max()
-        min2, max2 = proj2.min(), proj2.max()
-        # Check for separation (with small tolerance for shared-edge adjacency)
-        if max1 < min2 - 1e-9 or max2 < min1 - 1e-9:
-            return False  # separating axis found
-    return True  # no separating axis → intersection
-# ────────────────────────────────────────────────────────────────────
-# Combined validation
-# ────────────────────────────────────────────────────────────────────
-def validate_paper(paper: Paper) -> ValidationResult:
-    """Run all validation checks and return a combined result."""
-    k_valid, k_violation = check_kawasaki(paper)
-    m_valid, m_violation = check_maekawa(paper)
-    si_valid, si_count = check_self_intersection(paper)
-    return ValidationResult(
-        kawasaki_valid=k_valid,
-        kawasaki_violation=k_violation,
-        maekawa_valid=m_valid,
-        maekawa_violation=m_violation,
-        intersection_free=si_valid,
-        self_intersection_count=si_count,
-        is_valid=k_valid and m_valid and si_valid,
-    )

{engine → env}/__init__.py RENAMED Viewed

File without changes

env/environment.py ADDED Viewed

	@@ -0,0 +1,260 @@

+import copy
+import json
+from pathlib import Path
+from typing import Optional
+from .paper_state import PaperState
+from .rewards import compute_reward, compute_terminal_reward
+from .prompts import (
+    code_as_policy_prompt,
+    get_semantic_description,
+    step_level_prompt,
+    parse_fold_list,
+    parse_single_fold,
+)
+from .verifier import check_all_vertices
+TARGETS_DIR = Path(__file__).parent / 'targets'
+class OrigamiEnvironment:
+    """
+    OpenEnv-compatible origami crease pattern environment.
+    Supports two modes:
+    - code_as_policy: model outputs complete fold sequence, gets terminal reward
+    - step: model outputs one fold at a time, gets per-step reward
+    """
+    def __init__(
+        self,
+        mode: str = 'code_as_policy',  # 'code_as_policy' or 'step'
+        max_steps: int = 8,
+        targets_dir: Optional[str] = None,
+        use_semantic: bool = True,
+    ):
+        assert mode in ('code_as_policy', 'step'), f"Unknown mode: {mode}"
+        self.mode = mode
+        self.max_steps = max_steps
+        self.targets_dir = Path(targets_dir) if targets_dir else TARGETS_DIR
+        self.use_semantic = use_semantic
+        self.paper: Optional[PaperState] = None
+        self.target: Optional[dict] = None
+        self.target_name: Optional[str] = None
+        self.step_count: int = 0
+        self.last_reward: Optional[dict] = None
+        self._targets = self._load_all_targets()
+    def _load_all_targets(self) -> dict[str, dict]:
+        targets = {}
+        for fold_file in self.targets_dir.glob('*.fold'):
+            with open(fold_file) as f:
+                targets[fold_file.stem] = json.load(f)
+        return targets
+    def available_targets(self) -> list[str]:
+        return sorted(self._targets.keys())
+    def reset(self, target_name: Optional[str] = None) -> dict:
+        """
+        Reset environment to start of a new episode.
+        Args:
+            target_name: name of target (stem of .fold file). If None, picks level-1 randomly.
+        Returns:
+            observation dict with 'prompt' key containing the LLM prompt string.
+        """
+        import random
+        if target_name:
+            assert target_name in self._targets, f"Unknown target: {target_name}"
+            self.target_name = target_name
+        else:
+            # Default to level-1 targets
+            level1 = [k for k, v in self._targets.items() if v.get('level', 1) == 1]
+            self.target_name = random.choice(level1 if level1 else list(self._targets.keys()))
+        self.target = self._targets[self.target_name]
+        self.paper = PaperState()
+        self.step_count = 0
+        self.last_reward = None
+        return self._get_observation()
+    def step(self, action) -> tuple[dict, dict, bool, dict]:
+        """
+        Execute an action.
+        In code_as_policy mode: action is a string (model completion with <folds> tags)
+            OR a list of fold dicts already parsed.
+        In step mode: action is a string (single fold JSON) or dict.
+        Returns:
+            (observation, reward, done, info)
+        """
+        if self.mode == 'code_as_policy':
+            return self._step_sequence(action)
+        else:
+            return self._step_single(action)
+    def _step_sequence(self, action) -> tuple[dict, dict, bool, dict]:
+        """Execute a complete fold sequence (code-as-policy mode)."""
+        # Parse action if it's a string
+        if isinstance(action, str):
+            try:
+                folds = parse_fold_list(action)
+            except ValueError as e:
+                bad_reward = {'format': 0.0, 'total': -0.1, 'error': str(e)}
+                return self._get_observation(), bad_reward, True, self._info()
+        else:
+            folds = action  # already a list of dicts
+        # Execute each fold sequentially
+        last_result = {'valid': True, 'anchored': True, 'new_vertices': [], 'errors': []}
+        for fold in folds:
+            try:
+                p1 = fold['from']
+                p2 = fold['to']
+                assignment = fold['assignment']
+            except (KeyError, TypeError) as e:
+                last_result = {'valid': False, 'anchored': False, 'new_vertices': [], 'errors': [str(e)]}
+                break
+            last_result = self.paper.add_crease(p1, p2, assignment)
+            self.step_count += 1
+            if not last_result['valid']:
+                break  # stop at first invalid fold, partial credit
+        reward = compute_terminal_reward(self.paper, self.target, self.max_steps)
+        self.last_reward = reward
+        return self._get_observation(), reward, True, self._info()
+    def _step_single(self, action) -> tuple[dict, dict, bool, dict]:
+        """Execute a single fold (step mode)."""
+        if isinstance(action, str):
+            try:
+                fold = parse_single_fold(action)
+            except ValueError as e:
+                bad_reward = {'format': 0.0, 'total': -0.1, 'error': str(e)}
+                self.last_reward = bad_reward
+                done = self.step_count >= self.max_steps
+                return self._get_observation(), bad_reward, done, self._info()
+        else:
+            fold = action
+        try:
+            p1 = fold['from']
+            p2 = fold['to']
+            assignment = fold['assignment']
+        except (KeyError, TypeError) as e:
+            bad_reward = {'format': 0.0, 'total': -0.1, 'error': str(e)}
+            self.last_reward = bad_reward
+            done = self.step_count >= self.max_steps
+            return self._get_observation(), bad_reward, done, self._info()
+        prev_state = copy.deepcopy(self.paper)
+        result = self.paper.add_crease(p1, p2, assignment)
+        self.step_count += 1
+        reward = compute_reward(
+            prev_state=prev_state,
+            action_result=result,
+            new_state=self.paper,
+            target=self.target,
+            step=self.step_count,
+            max_steps=self.max_steps,
+        )
+        self.last_reward = reward
+        done = (
+            self.step_count >= self.max_steps or
+            reward.get('completion', 0) > 0
+        )
+        return self._get_observation(), reward, done, self._info()
+    def _get_observation(self) -> dict:
+        """Returns observation dict with the LLM prompt and raw state."""
+        desc = None
+        if self.use_semantic and self.target_name and self.target:
+            desc = get_semantic_description(self.target_name, self.target)
+        if self.mode == 'code_as_policy':
+            prompt = code_as_policy_prompt(
+                self.target, max_folds=self.max_steps, semantic_description=desc,
+            )
+        else:
+            prompt = step_level_prompt(
+                target=self.target,
+                paper_state=self.paper,
+                step=self.step_count,
+                max_steps=self.max_steps,
+                last_reward=self.last_reward,
+                semantic_description=desc,
+            )
+        return {
+            'prompt': prompt,
+            'target_name': self.target_name,
+            'step': self.step_count,
+            'paper_fold_json': self.paper.graph.edges if self.paper else {},
+        }
+    def _info(self) -> dict:
+        """Returns diagnostic info dict for logging."""
+        if self.paper is None:
+            return {}
+        interior = self.paper.graph.interior_vertices()
+        vertex_scores = check_all_vertices(self.paper.graph)
+        return {
+            'local_foldability': (
+                vertex_scores['kawasaki'] == 1.0 and
+                vertex_scores['maekawa'] == 1.0
+            ),
+            'blb_satisfied': vertex_scores['blb'] == 1.0,
+            'global_foldability': 'not_checked',  # NP-complete (Bern-Hayes 1996)
+            'n_interior_vertices': len(interior),
+            'n_creases': len(self.paper.graph.crease_edges()),
+            'target_name': self.target_name,
+        }
+    def state(self) -> dict:
+        """Returns current environment state for logging/inspection."""
+        return {
+            'paper': {
+                'vertices': dict(self.paper.graph.vertices),
+                'edges': {
+                    k: v for k, v in self.paper.graph.edges.items()
+                    if v[2] in ('M', 'V')
+                },
+                'fold_history': self.paper.fold_history,
+            },
+            'target': self.target_name,
+            'step': self.step_count,
+            'mode': self.mode,
+        }
+    def close(self):
+        """Cleanup."""
+        pass
+    def clone(self) -> 'OrigamiEnvironment':
+        """Return a deep copy for parallel evaluation (used in GRPO)."""
+        new_env = OrigamiEnvironment(
+            mode=self.mode,
+            max_steps=self.max_steps,
+            targets_dir=str(self.targets_dir),
+            use_semantic=self.use_semantic,
+        )
+        if self.paper is not None:
+            new_env.paper = copy.deepcopy(self.paper)
+        new_env.target = self.target
+        new_env.target_name = self.target_name
+        new_env.step_count = self.step_count
+        new_env.last_reward = self.last_reward
+        return new_env

env/graph.py ADDED Viewed

	@@ -0,0 +1,117 @@

+import numpy as np
+from typing import Optional
+BOUNDARY_TOL = 1e-9
+VERTEX_TOL = 1e-9
+class CreaseGraph:
+    """
+    Planar graph representing an origami crease pattern on a unit square.
+    Vertices: points in [0,1]x[0,1], deduplicated by proximity.
+    Edges: segments between vertices, labeled M (mountain), V (valley), or B (boundary).
+    """
+    def __init__(self):
+        self.vertices: dict[int, tuple[float, float]] = {}
+        self.edges: dict[int, tuple[int, int, str]] = {}
+        self.vertex_edges: dict[int, list[int]] = {}
+        self._next_vertex_id: int = 0
+        self._next_edge_id: int = 0
+        corners = [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)]
+        for x, y in corners:
+            vid = self._next_vertex_id
+            self.vertices[vid] = (x, y)
+            self.vertex_edges[vid] = []
+            self._next_vertex_id += 1
+        boundary_pairs = [(0, 1), (1, 2), (2, 3), (3, 0)]
+        for v1, v2 in boundary_pairs:
+            eid = self._next_edge_id
+            self.edges[eid] = (v1, v2, 'B')
+            self.vertex_edges[v1].append(eid)
+            self.vertex_edges[v2].append(eid)
+            self._next_edge_id += 1
+    def add_vertex(self, x: float, y: float) -> int:
+        for vid, (vx, vy) in self.vertices.items():
+            if abs(vx - x) < VERTEX_TOL and abs(vy - y) < VERTEX_TOL:
+                return vid
+        vid = self._next_vertex_id
+        self.vertices[vid] = (float(x), float(y))
+        self.vertex_edges[vid] = []
+        self._next_vertex_id += 1
+        return vid
+    def add_edge(self, v1_id: int, v2_id: int, assignment: str) -> int:
+        pair = frozenset((v1_id, v2_id))
+        for eid, (ev1, ev2, _) in self.edges.items():
+            if frozenset((ev1, ev2)) == pair:
+                return eid
+        eid = self._next_edge_id
+        self.edges[eid] = (v1_id, v2_id, assignment)
+        self.vertex_edges[v1_id].append(eid)
+        self.vertex_edges[v2_id].append(eid)
+        self._next_edge_id += 1
+        return eid
+    def get_cyclic_edges(self, vertex_id: int) -> list[int]:
+        vx, vy = self.vertices[vertex_id]
+        edge_ids = self.vertex_edges[vertex_id]
+        def angle_of_edge(eid: int) -> float:
+            ev1, ev2, _ = self.edges[eid]
+            other_id = ev2 if ev1 == vertex_id else ev1
+            ox, oy = self.vertices[other_id]
+            return float(np.arctan2(oy - vy, ox - vx))
+        return sorted(edge_ids, key=angle_of_edge)
+    def interior_vertices(self) -> list[int]:
+        result = []
+        for vid, (x, y) in self.vertices.items():
+            if (
+                x > BOUNDARY_TOL
+                and x < 1.0 - BOUNDARY_TOL
+                and y > BOUNDARY_TOL
+                and y < 1.0 - BOUNDARY_TOL
+            ):
+                result.append(vid)
+        return result
+    def split_edge(self, edge_id: int, new_vertex_id: int) -> tuple[int, int]:
+        ev1, ev2, assignment = self.edges[edge_id]
+        del self.edges[edge_id]
+        if edge_id in self.vertex_edges[ev1]:
+            self.vertex_edges[ev1].remove(edge_id)
+        if edge_id in self.vertex_edges[ev2]:
+            self.vertex_edges[ev2].remove(edge_id)
+        eid1 = self._next_edge_id
+        self.edges[eid1] = (ev1, new_vertex_id, assignment)
+        self.vertex_edges[ev1].append(eid1)
+        self.vertex_edges[new_vertex_id].append(eid1)
+        self._next_edge_id += 1
+        eid2 = self._next_edge_id
+        self.edges[eid2] = (new_vertex_id, ev2, assignment)
+        self.vertex_edges[new_vertex_id].append(eid2)
+        self.vertex_edges[ev2].append(eid2)
+        self._next_edge_id += 1
+        return (eid1, eid2)
+    def crease_edges(self) -> list[int]:
+        return [eid for eid, (_, _, a) in self.edges.items() if a in ('M', 'V')]
+    def boundary_midpoints(self) -> list[tuple[float, float]]:
+        midpoints = []
+        for eid, (v1, v2, assignment) in self.edges.items():
+            if assignment == 'B':
+                x1, y1 = self.vertices[v1]
+                x2, y2 = self.vertices[v2]
+                midpoints.append(((x1 + x2) / 2.0, (y1 + y2) / 2.0))
+        return midpoints

env/paper_state.py ADDED Viewed

	@@ -0,0 +1,164 @@

+import numpy as np
+from shapely.geometry import LineString, Point, Polygon
+from typing import Optional
+from .graph import CreaseGraph, VERTEX_TOL
+UNIT_SQUARE_CORNERS = [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)]
+_UNIT_SQUARE = Polygon(UNIT_SQUARE_CORNERS)
+class PaperState:
+    """
+    Represents the evolving crease pattern on a unit square [0,1]x[0,1].
+    Uses CreaseGraph for the underlying data structure.
+    """
+    def __init__(self):
+        self.graph = CreaseGraph()
+        self.fold_history: list[dict] = []
+    def anchor_points(self) -> list[tuple[float, float]]:
+        points: dict[tuple[float, float], None] = {}
+        for corner in UNIT_SQUARE_CORNERS:
+            points[corner] = None
+        for vid, (x, y) in self.graph.vertices.items():
+            points[(float(x), float(y))] = None
+        return list(points.keys())
+    def _is_anchor(self, pt: tuple[float, float]) -> bool:
+        px, py = pt
+        for ax, ay in self.anchor_points():
+            if abs(ax - px) < VERTEX_TOL and abs(ay - py) < VERTEX_TOL:
+                return True
+        return False
+    def _edge_exists(self, v1_id: int, v2_id: int) -> bool:
+        """Check if an edge already exists between the two vertex IDs."""
+        pair = frozenset((v1_id, v2_id))
+        for ev1, ev2, _ in self.graph.edges.values():
+            if frozenset((ev1, ev2)) == pair:
+                return True
+        return False
+    def add_crease(self, p1: list, p2: list, assignment: str) -> dict:
+        errors: list[str] = []
+        if assignment not in ('M', 'V'):
+            return {
+                'valid': False,
+                'anchored': False,
+                'new_vertices': [],
+                'errors': ['invalid_assignment'],
+                'duplicate': False,
+            }
+        p1 = (float(p1[0]), float(p1[1]))
+        p2 = (float(p2[0]), float(p2[1]))
+        anchored = self._is_anchor(p1) and self._is_anchor(p2)
+        seg_len = np.hypot(p2[0] - p1[0], p2[1] - p1[1])
+        if seg_len < VERTEX_TOL:
+            errors.append('zero_length')
+            return {'valid': False, 'anchored': anchored, 'new_vertices': [], 'errors': errors, 'duplicate': False}
+        new_line = LineString([p1, p2])
+        if not _UNIT_SQUARE.contains(new_line) and not _UNIT_SQUARE.boundary.contains(new_line):
+            clipped = new_line.intersection(_UNIT_SQUARE)
+            if clipped.is_empty:
+                errors.append('outside_bounds')
+                return {'valid': False, 'anchored': anchored, 'new_vertices': [], 'errors': errors, 'duplicate': False}
+        intersection_points: list[tuple[float, float]] = []
+        for eid, (ev1, ev2, _) in list(self.graph.edges.items()):
+            ex1, ey1 = self.graph.vertices[ev1]
+            ex2, ey2 = self.graph.vertices[ev2]
+            existing_line = LineString([(ex1, ey1), (ex2, ey2)])
+            inter = new_line.intersection(existing_line)
+            if inter.is_empty:
+                continue
+            if inter.geom_type == 'Point':
+                ix, iy = inter.x, inter.y
+                ep1 = (ex1, ey1)
+                ep2 = (ex2, ey2)
+                if (
+                    abs(ix - ep1[0]) < VERTEX_TOL and abs(iy - ep1[1]) < VERTEX_TOL
+                    or abs(ix - ep2[0]) < VERTEX_TOL and abs(iy - ep2[1]) < VERTEX_TOL
+                ):
+                    continue
+                intersection_points.append((ix, iy))
+            # MultiPoint or LineString intersections (collinear) are skipped
+        new_vertex_coords: list[tuple[float, float]] = []
+        for ix, iy in intersection_points:
+            before = set(self.graph.vertices.keys())
+            vid = self.graph.add_vertex(ix, iy)
+            if vid not in before:
+                new_vertex_coords.append((ix, iy))
+            for eid in list(self.graph.edges.keys()):
+                if eid not in self.graph.edges:
+                    continue
+                ev1, ev2, _ = self.graph.edges[eid]
+                ex1, ey1 = self.graph.vertices[ev1]
+                ex2, ey2 = self.graph.vertices[ev2]
+                seg = LineString([(ex1, ey1), (ex2, ey2)])
+                pt = Point(ix, iy)
+                if seg.distance(pt) < VERTEX_TOL:
+                    if ev1 != vid and ev2 != vid:
+                        self.graph.split_edge(eid, vid)
+        v1_id = self.graph.add_vertex(p1[0], p1[1])
+        v2_id = self.graph.add_vertex(p2[0], p2[1])
+        waypoints = [p1] + sorted(
+            intersection_points,
+            key=lambda pt: np.hypot(pt[0] - p1[0], pt[1] - p1[1]),
+        ) + [p2]
+        waypoint_ids = []
+        for wp in waypoints:
+            wid = self.graph.add_vertex(wp[0], wp[1])
+            waypoint_ids.append(wid)
+        duplicate = any(
+            self._edge_exists(waypoint_ids[i], waypoint_ids[i + 1])
+            for i in range(len(waypoint_ids) - 1)
+        )
+        for i in range(len(waypoint_ids) - 1):
+            wa = waypoint_ids[i]
+            wb = waypoint_ids[i + 1]
+            if wa != wb:
+                self.graph.add_edge(wa, wb, assignment)
+        record = {
+            'p1': p1,
+            'p2': p2,
+            'assignment': assignment,
+            'anchored': anchored,
+            'new_vertices': new_vertex_coords,
+        }
+        self.fold_history.append(record)
+        return {
+            'valid': True,
+            'anchored': anchored,
+            'new_vertices': new_vertex_coords,
+            'errors': errors,
+            'duplicate': duplicate,
+        }
+    def crease_edges(self) -> list[dict]:
+        result = []
+        for eid in self.graph.crease_edges():
+            v1, v2, assignment = self.graph.edges[eid]
+            x1, y1 = self.graph.vertices[v1]
+            x2, y2 = self.graph.vertices[v2]
+            result.append({'v1': (x1, y1), 'v2': (x2, y2), 'assignment': assignment})
+        return result

env/prompts.py ADDED Viewed

	@@ -0,0 +1,284 @@

+import json
+import re
+from typing import Optional
+_CORNERS = {(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)}
+_BOUNDARY_X = {0.0, 1.0}
+_BOUNDARY_Y = {0.0, 1.0}
+# Semantic descriptions for known target patterns (used when target coords are hidden)
+DESCRIPTIONS: dict[str, str] = {
+    "valley_fold_half": "Fold the paper in half with a single valley fold along the horizontal center line.",
+    "mountain_fold_half": "Fold the paper in half with a single mountain fold along the vertical center line.",
+    "letter_fold": "Create a letter fold (two parallel valley folds dividing the paper into thirds).",
+    "diagonal_fold": "Fold the paper diagonally from one corner to the opposite corner.",
+    "waterbomb_base": "Create a waterbomb base with two valley folds along both diagonals.",
+}
+def _is_corner(x: float, y: float) -> bool:
+    return (round(x, 4), round(y, 4)) in _CORNERS
+def _is_boundary(x: float, y: float) -> bool:
+    return x in _BOUNDARY_X or y in _BOUNDARY_Y
+def format_target_for_prompt(target: dict) -> str:
+    vertices = target["vertices_coords"]
+    edges_v = target["edges_vertices"]
+    edges_a = target["edges_assignment"]
+    lines = []
+    for (v1, v2), assignment in zip(edges_v, edges_a):
+        if assignment not in ("M", "V"):
+            continue
+        x1, y1 = vertices[v1]
+        x2, y2 = vertices[v2]
+        label = "Mountain" if assignment == "M" else "Valley"
+        lines.append(
+            f"{label} fold: ({round(x1, 4)}, {round(y1, 4)}) -> ({round(x2, 4)}, {round(y2, 4)})"
+        )
+    return "\n".join(lines)
+def get_semantic_description(target_name: str, target: dict) -> str:
+    """Return a natural language description of the target crease pattern."""
+    if target_name in DESCRIPTIONS:
+        return DESCRIPTIONS[target_name]
+    # Fallback: generate from target dict structure
+    edges_a = target.get("edges_assignment", [])
+    valley_count = sum(1 for a in edges_a if a == "V")
+    mountain_count = sum(1 for a in edges_a if a == "M")
+    if valley_count or mountain_count:
+        parts = []
+        if valley_count:
+            parts.append(f"{valley_count} valley fold{'s' if valley_count != 1 else ''}")
+        if mountain_count:
+            parts.append(f"{mountain_count} mountain fold{'s' if mountain_count != 1 else ''}")
+        return f"Create an origami crease pattern with {', '.join(parts)}."
+    return "Create an origami crease pattern with the given folds."
+def format_anchor_points(paper_state) -> str:
+    corners = []
+    boundary_pts = []
+    intersections = []
+    for x, y in paper_state.anchor_points():
+        rx, ry = round(x, 4), round(y, 4)
+        if _is_corner(rx, ry):
+            corners.append((rx, ry))
+        elif _is_boundary(rx, ry):
+            boundary_pts.append((rx, ry))
+        else:
+            intersections.append((rx, ry))
+    def fmt_pts(pts: list[tuple[float, float]]) -> str:
+        return "  ".join(f"({x},{y})" for x, y in pts)
+    lines = []
+    if corners:
+        lines.append(f"  Corners:       {fmt_pts(corners)}")
+    if boundary_pts:
+        lines.append(f"  Boundary pts:  {fmt_pts(boundary_pts)}")
+    if intersections:
+        lines.append(f"  Intersections: {fmt_pts(intersections)}")
+    return "\n".join(lines)
+def format_crease_history(paper_state) -> str:
+    history = paper_state.fold_history
+    if not history:
+        return "none"
+    lines = []
+    for i, fold in enumerate(history, 1):
+        p1, p2 = fold["p1"], fold["p2"]
+        assignment = fold["assignment"]
+        label = "Mountain" if assignment == "M" else "Valley"
+        x1, y1 = round(p1[0], 4), round(p1[1], 4)
+        x2, y2 = round(p2[0], 4), round(p2[1], 4)
+        lines.append(f"  {i}. {label} fold: ({x1}, {y1}) -> ({x2}, {y2})")
+    return "\n".join(lines)
+def format_reward_feedback(reward: Optional[dict]) -> str:
+    if not reward:
+        return "(no feedback yet)"
+    keys = ["kawasaki", "maekawa", "blb", "progress", "economy", "total"]
+    parts = []
+    for k in keys:
+        if k in reward:
+            parts.append(f"{k}={reward[k]:.2f}")
+    for k, v in reward.items():
+        if k not in keys:
+            parts.append(f"{k}={v:.2f}")
+    return "  " + "  ".join(parts)
+def code_as_policy_prompt(
+    target: dict,
+    max_folds: int = 8,
+    semantic_description: Optional[str] = None,
+) -> str:
+    if semantic_description is not None:
+        target_section = f"""TASK:
+{semantic_description}
+You are an origami designer. Given a description of what to fold, output a sequence of fold operations that build a crease pattern on a unit square [0,1]x[0,1]."""
+    else:
+        formatted_target = format_target_for_prompt(target)
+        target_section = f"""TARGET CREASE PATTERN:
+{formatted_target}
+You are an origami designer. Generate a fold sequence for a unit square [0,1]x[0,1]."""
+    return f"""{target_section}
+RULES (must hold at every interior vertex):
+  - Kawasaki: alternating sector angles sum equally (each half = 180 degrees)
+  - Maekawa: |mountain_count - valley_count| = 2
+  - Big-Little-Big: folds bounding the smallest sector must have opposite types (one M, one V)
+INITIAL ANCHOR POINTS (valid fold endpoints — new ones appear when creases intersect):
+  Corners:      (0.0,0.0)  (1.0,0.0)  (1.0,1.0)  (0.0,1.0)
+  Midpoints:    (0.0,0.5)  (0.5,0.0)  (1.0,0.5)  (0.5,1.0)
+  Note: new anchor points are created at crease intersections.
+Output at most {max_folds} folds. Both endpoints must be valid anchor points.
+Output ONLY the JSON list, wrapped in <folds> tags:
+<folds>
+[
+  {{"instruction": "Describe the fold in plain English", "from": [x1, y1], "to": [x2, y2], "assignment": "V"}},
+  {{"instruction": "...", "from": [x1, y1], "to": [x2, y2], "assignment": "M"}}
+]
+</folds>"""
+def step_level_prompt(
+    target: dict,
+    paper_state,
+    step: int,
+    max_steps: int,
+    last_reward: Optional[dict] = None,
+    semantic_description: Optional[str] = None,
+) -> str:
+    if semantic_description is not None:
+        target_section = f"""TASK:
+{semantic_description}
+You are an origami designer. Given a description of what to fold, add the next crease to build the pattern."""
+    else:
+        formatted_target = format_target_for_prompt(target)
+        target_section = f"""TARGET:
+{formatted_target}
+You are an origami designer building a crease pattern step by step."""
+    formatted_history = format_crease_history(paper_state)
+    formatted_anchors = format_anchor_points(paper_state)
+    formatted_reward = format_reward_feedback(last_reward)
+    return f"""{target_section}
+CURRENT STATE (step {step} of {max_steps}):
+  Creases placed:
+{formatted_history}
+AVAILABLE ANCHOR POINTS:
+{formatted_anchors}
+LAST REWARD:
+{formatted_reward}
+Add the NEXT crease. Both endpoints must be listed anchor points above.
+Output ONLY valid JSON (no extra text):
+{{"instruction": "...", "from": [x1, y1], "to": [x2, y2], "assignment": "M" or "V"}}"""
+def parse_fold_list(completion: str) -> list[dict]:
+    match = re.search(r"<folds>(.*?)</folds>", completion, re.IGNORECASE | re.DOTALL)
+    if not match:
+        raise ValueError("No <folds>...</folds> tags found in completion")
+    raw = match.group(1).strip()
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Failed to parse JSON inside <folds> tags: {e}") from e
+    if not isinstance(data, list):
+        raise ValueError(f"Expected a JSON list inside <folds> tags, got {type(data).__name__}")
+    cleaned = []
+    for i, item in enumerate(data):
+        if not isinstance(item, dict):
+            raise ValueError(f"Fold {i} is not a dict: {item!r}")
+        for field in ("from", "to", "assignment"):
+            if field not in item:
+                raise ValueError(f"Fold {i} missing required field '{field}'")
+        from_pt = item["from"]
+        to_pt = item["to"]
+        if (
+            not isinstance(from_pt, list)
+            or len(from_pt) != 2
+            or not all(isinstance(v, (int, float)) for v in from_pt)
+        ):
+            raise ValueError(f"Fold {i} 'from' must be a list of 2 numbers, got {from_pt!r}")
+        if (
+            not isinstance(to_pt, list)
+            or len(to_pt) != 2
+            or not all(isinstance(v, (int, float)) for v in to_pt)
+        ):
+            raise ValueError(f"Fold {i} 'to' must be a list of 2 numbers, got {to_pt!r}")
+        if not isinstance(item["assignment"], str):
+            raise ValueError(f"Fold {i} 'assignment' must be a string")
+        cleaned.append(
+            {
+                "from": [float(from_pt[0]), float(from_pt[1])],
+                "to": [float(to_pt[0]), float(to_pt[1])],
+                "assignment": item["assignment"],
+                "instruction": item.get("instruction", ""),
+            }
+        )
+    return cleaned
+def parse_single_fold(completion: str) -> dict:
+    start = completion.find("{")
+    end = completion.rfind("}")
+    if start == -1 or end == -1 or end <= start:
+        raise ValueError("No JSON object found in completion")
+    raw = completion[start : end + 1]
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Failed to parse JSON from completion: {e}") from e
+    if not isinstance(data, dict):
+        raise ValueError(f"Expected a JSON object, got {type(data).__name__}")
+    for field in ("from", "to", "assignment"):
+        if field not in data:
+            raise ValueError(f"Missing required field '{field}' in fold JSON")
+    return data

env/rewards.py ADDED Viewed

	@@ -0,0 +1,135 @@

+import json
+from .verifier import check_all_vertices, check_degree_sanity, geometric_crease_coverage
+from .paper_state import PaperState
+def load_target(target_path: str) -> dict:
+    """Load a .fold target file and return it as a dict."""
+    with open(target_path) as f:
+        return json.load(f)
+def target_crease_edges(target: dict) -> list[dict]:
+    """
+    Extract crease edges from a FOLD target dict as list of
+    {'v1': (x1,y1), 'v2': (x2,y2), 'assignment': 'M'|'V'} dicts.
+    """
+    verts = target['vertices_coords']
+    result = []
+    for i, (v1_idx, v2_idx) in enumerate(target['edges_vertices']):
+        assignment = target['edges_assignment'][i]
+        if assignment in ('M', 'V'):
+            result.append({
+                'v1': tuple(verts[v1_idx]),
+                'v2': tuple(verts[v2_idx]),
+                'assignment': assignment,
+            })
+    return result
+def compute_reward(
+    prev_state: PaperState,
+    action_result: dict,
+    new_state: PaperState,
+    target: dict,
+    step: int,
+    max_steps: int,
+) -> dict:
+    """
+    Compute the full reward dict for a fold action (lexicographically gated).
+    Args:
+        prev_state: PaperState BEFORE the action was applied
+        action_result: {'valid': bool, 'anchored': bool, 'duplicate': bool, ...}
+        new_state: PaperState AFTER the action was applied
+        target: FOLD target dict
+        step: current step index
+        max_steps: maximum steps in episode
+    Returns dict with keys:
+        format, anchored, novelty, kawasaki, maekawa, blb, degree_sanity,
+        progress, economy, assignment_accuracy, delta, regression,
+        completion, efficiency, total
+    """
+    r = {}
+    # GATE 1: Format — did the action parse and apply?
+    r['format'] = 1.0 if action_result.get('valid', False) else 0.0
+    if not r['format']:
+        r['total'] = -0.1
+        return r
+    # GATE 2: Structural sanity
+    r['anchored'] = 1.0 if action_result.get('anchored', False) else 0.3
+    r['novelty'] = 0.0 if action_result.get('duplicate', False) is True else 0.2
+    # LEVEL 3: Local flat-foldability
+    vertex_scores = check_all_vertices(new_state.graph)
+    r['kawasaki'] = vertex_scores['kawasaki']
+    r['maekawa'] = vertex_scores['maekawa']
+    r['blb'] = vertex_scores['blb']
+    r['degree_sanity'] = check_degree_sanity(new_state.graph)
+    # LEVEL 4: Progress (absolute + delta)
+    t_edges = target_crease_edges(target)
+    old_coverage, _, _ = geometric_crease_coverage(prev_state, t_edges)
+    new_coverage, economy, assignment_accuracy = geometric_crease_coverage(new_state, t_edges)
+    r['progress'] = new_coverage
+    r['economy'] = economy
+    r['assignment_accuracy'] = assignment_accuracy
+    r['delta'] = max(0.0, new_coverage - old_coverage)
+    r['regression'] = min(0.0, new_coverage - old_coverage)
+    # LEVEL 5: Completion bonus
+    all_valid = (
+        r['kawasaki'] == 1.0
+        and r['maekawa'] == 1.0
+        and r['blb'] == 1.0
+    )
+    r['completion'] = 10.0 if (r['progress'] > 0.9 and all_valid) else 0.0
+    # LEVEL 6: Efficiency — escalating step cost
+    r['efficiency'] = -0.01 * (1 + step / max_steps)
+    # Weighted total
+    r['total'] = (
+        0.05 * r['anchored']
+        + 0.05 * r['novelty']
+        + 0.06 * r['kawasaki']
+        + 0.06 * r['maekawa']
+        + 0.04 * r['blb']
+        + 0.04 * r['degree_sanity']
+        + 0.25 * r['progress']
+        + 0.05 * r['economy']
+        + 0.05 * r['assignment_accuracy']
+        + 0.20 * r['delta']
+        + 0.10 * r['regression']
+        + r['completion']
+        + r['efficiency']
+    )
+    return r
+def compute_terminal_reward(
+    state: PaperState,
+    target: dict,
+    max_steps: int,
+) -> dict:
+    """
+    Compute reward for the final state after a complete fold sequence.
+    Uses fresh PaperState as baseline and step = max_steps.
+    """
+    fake_result = {
+        'valid': True,
+        'anchored': True,
+        'duplicate': False,
+    }
+    return compute_reward(
+        prev_state=PaperState(),
+        action_result=fake_result,
+        new_state=state,
+        target=target,
+        step=max_steps,
+        max_steps=max_steps,
+    )

{planner → env/targets}/__init__.py RENAMED Viewed

File without changes

env/targets/accordion_3h.fold ADDED Viewed

	@@ -0,0 +1,67 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0],
+    [0.0, 0.25],
+    [1.0, 0.25],
+    [0.0, 0.5],
+    [1.0, 0.5],
+    [0.0, 0.75],
+    [1.0, 0.75]
+  ],
+  "edges_vertices": [
+    [0, 1],
+    [1, 5],
+    [5, 7],
+    [7, 9],
+    [9, 2],
+    [2, 3],
+    [3, 8],
+    [8, 6],
+    [6, 4],
+    [4, 0],
+    [4, 5],
+    [6, 7],
+    [8, 9]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "V",
+    "M",
+    "V"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    -180,
+    -180,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 1, 5, 4],
+    [4, 5, 7, 6],
+    [6, 7, 9, 8],
+    [8, 9, 2, 3]
+  ],
+  "level": 3,
+  "description": "Three alternating horizontal folds at y=0.25 (valley), y=0.5 (mountain), y=0.75 (valley) forming an accordion"
+}

env/targets/accordion_4h.fold ADDED Viewed

	@@ -0,0 +1,79 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0],
+    [0.0, 0.2],
+    [1.0, 0.2],
+    [0.0, 0.4],
+    [1.0, 0.4],
+    [0.0, 0.6],
+    [1.0, 0.6],
+    [0.0, 0.8],
+    [1.0, 0.8]
+  ],
+  "edges_vertices": [
+    [0, 1],
+    [1, 5],
+    [5, 7],
+    [7, 9],
+    [9, 11],
+    [11, 2],
+    [2, 3],
+    [3, 10],
+    [10, 8],
+    [8, 6],
+    [6, 4],
+    [4, 0],
+    [4, 5],
+    [6, 7],
+    [8, 9],
+    [10, 11]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "V",
+    "M",
+    "V",
+    "M"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    -180,
+    -180,
+    -180,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 1, 5, 4],
+    [4, 5, 7, 6],
+    [6, 7, 9, 8],
+    [8, 9, 11, 10],
+    [10, 11, 2, 3]
+  ],
+  "level": 3,
+  "description": "Four alternating horizontal folds at y=0.2 (valley), y=0.4 (mountain), y=0.6 (valley), y=0.8 (mountain) forming an accordion"
+}

env/targets/diagonal_anti.fold ADDED Viewed

	@@ -0,0 +1,35 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0]
+  ],
+  "edges_vertices": [
+    [0, 1],
+    [1, 2],
+    [2, 3],
+    [3, 0],
+    [1, 3]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "M"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 1, 3],
+    [1, 2, 3]
+  ],
+  "level": 1,
+  "description": "One mountain fold along the anti-diagonal from (1,0) to (0,1)"
+}

env/targets/diagonal_main.fold ADDED Viewed

	@@ -0,0 +1,35 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0]
+  ],
+  "edges_vertices": [
+    [0, 1],
+    [1, 2],
+    [2, 3],
+    [3, 0],
+    [0, 2]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "V"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 1, 2],
+    [0, 2, 3]
+  ],
+  "level": 1,
+  "description": "One valley fold along the main diagonal from (0,0) to (1,1)"
+}

env/targets/half_horizontal.fold ADDED Viewed

	@@ -0,0 +1,43 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0],
+    [0.0, 0.5],
+    [1.0, 0.5]
+  ],
+  "edges_vertices": [
+    [0, 1],
+    [1, 5],
+    [5, 2],
+    [2, 3],
+    [3, 4],
+    [4, 0],
+    [4, 5]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "V"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 1, 5, 4],
+    [4, 5, 2, 3]
+  ],
+  "level": 1,
+  "description": "One valley fold along y=0.5, folding the paper in half horizontally"
+}

env/targets/half_vertical.fold ADDED Viewed

	@@ -0,0 +1,43 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0],
+    [0.5, 0.0],
+    [0.5, 1.0]
+  ],
+  "edges_vertices": [
+    [0, 4],
+    [4, 1],
+    [1, 2],
+    [2, 5],
+    [5, 3],
+    [3, 0],
+    [4, 5]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "M"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 4, 5, 3],
+    [4, 1, 2, 5]
+  ],
+  "level": 1,
+  "description": "One mountain fold along x=0.5, folding the paper in half vertically"
+}

env/targets/thirds_h.fold ADDED Viewed

	@@ -0,0 +1,55 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0],
+    [0.0, 0.3333333333333333],
+    [1.0, 0.3333333333333333],
+    [0.0, 0.6666666666666666],
+    [1.0, 0.6666666666666666]
+  ],
+  "edges_vertices": [
+    [0, 1],
+    [1, 5],
+    [5, 7],
+    [7, 2],
+    [2, 3],
+    [3, 6],
+    [6, 4],
+    [4, 0],
+    [4, 5],
+    [6, 7]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "V",
+    "V"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    -180,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 1, 5, 4],
+    [4, 5, 7, 6],
+    [6, 7, 2, 3]
+  ],
+  "level": 2,
+  "description": "Two parallel valley folds at y=1/3 and y=2/3, dividing the paper into horizontal thirds"
+}

env/targets/thirds_v.fold ADDED Viewed

	@@ -0,0 +1,55 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0],
+    [0.3333333333333333, 0.0],
+    [0.6666666666666666, 0.0],
+    [0.3333333333333333, 1.0],
+    [0.6666666666666666, 1.0]
+  ],
+  "edges_vertices": [
+    [0, 4],
+    [4, 5],
+    [5, 1],
+    [1, 2],
+    [2, 7],
+    [7, 6],
+    [6, 3],
+    [3, 0],
+    [4, 6],
+    [5, 7]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "M",
+    "M"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    -180,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 4, 6, 3],
+    [4, 5, 7, 6],
+    [5, 1, 2, 7]
+  ],
+  "level": 2,
+  "description": "Two parallel mountain folds at x=1/3 and x=2/3, dividing the paper into vertical thirds"
+}

env/targets/validator.py ADDED Viewed

	@@ -0,0 +1,119 @@

+"""
+Validates all .fold target files against origami theorems.
+Run directly: python -m env.targets.validator
+"""
+import json
+import os
+import sys
+from pathlib import Path
+from ..graph import CreaseGraph
+from ..verifier import check_kawasaki_at_vertex, check_maekawa_at_vertex, check_blb_at_vertex
+def build_graph_from_fold(fold_data: dict) -> CreaseGraph:
+    """
+    Reconstruct a CreaseGraph from a FOLD JSON dict.
+    Used to validate target files.
+    """
+    graph = CreaseGraph()
+    verts = fold_data['vertices_coords']
+    edges = fold_data['edges_vertices']
+    assignments = fold_data['edges_assignment']
+    # Map file vertex indices to graph vertex IDs
+    vert_map = {}
+    for i, (x, y) in enumerate(verts):
+        vid = graph.add_vertex(float(x), float(y))
+        vert_map[i] = vid
+    # Add edges (boundary edges from init may already exist, add_edge handles dedup)
+    for i, (v1_idx, v2_idx) in enumerate(edges):
+        v1_id = vert_map[v1_idx]
+        v2_id = vert_map[v2_idx]
+        assignment = assignments[i]
+        graph.add_edge(v1_id, v2_id, assignment)
+    return graph
+def validate_target(fold_path: str) -> dict:
+    """
+    Validate a single .fold target file.
+    Returns {'file': str, 'valid': bool, 'issues': list[str], 'interior_vertices': int}
+    """
+    with open(fold_path) as f:
+        fold_data = json.load(f)
+    issues = []
+    # Basic structure checks
+    required = ['vertices_coords', 'edges_vertices', 'edges_assignment', 'edges_foldAngle']
+    for field in required:
+        if field not in fold_data:
+            issues.append(f"Missing field: {field}")
+    if issues:
+        return {'file': os.path.basename(fold_path), 'valid': False, 'issues': issues, 'interior_vertices': -1}
+    n_edges = len(fold_data['edges_vertices'])
+    if len(fold_data['edges_assignment']) != n_edges:
+        issues.append("edges_assignment length mismatch")
+    if len(fold_data['edges_foldAngle']) != n_edges:
+        issues.append("edges_foldAngle length mismatch")
+    # Build graph and check theorems
+    graph = build_graph_from_fold(fold_data)
+    interior = graph.interior_vertices()
+    for v_id in interior:
+        ok, alt_sum = check_kawasaki_at_vertex(v_id, graph)
+        if not ok:
+            issues.append(f"Kawasaki violated at vertex {v_id} (alt_sum={alt_sum:.6f})")
+        if not check_maekawa_at_vertex(v_id, graph):
+            issues.append(f"Maekawa violated at vertex {v_id}")
+        blb_violations = check_blb_at_vertex(v_id, graph)
+        if blb_violations:
+            issues.append(f"BLB violated at vertex {v_id}: {blb_violations}")
+    return {
+        'file': os.path.basename(fold_path),
+        'valid': len(issues) == 0,
+        'issues': issues,
+        'interior_vertices': len(interior),
+    }
+def validate_all(targets_dir: str = None) -> bool:
+    """Validate all .fold files in the targets directory. Returns True if all pass."""
+    if targets_dir is None:
+        targets_dir = Path(__file__).parent
+    all_pass = True
+    fold_files = sorted(Path(targets_dir).glob('*.fold'))
+    if not fold_files:
+        print("No .fold files found")
+        return False
+    for fold_path in fold_files:
+        result = validate_target(str(fold_path))
+        status = "OK" if result['valid'] else "FAIL"
+        n_interior = result['interior_vertices']
+        print(f"  [{status}] {result['file']} — {n_interior} interior vertices")
+        if result['issues']:
+            for issue in result['issues']:
+                print(f"         ! {issue}")
+        if not result['valid']:
+            all_pass = False
+    return all_pass
+if __name__ == '__main__':
+    print("Validating targets...")
+    ok = validate_all()
+    sys.exit(0 if ok else 1)

env/targets/validator_check.py ADDED Viewed

	@@ -0,0 +1,21 @@

+import json
+import os
+from pathlib import Path
+targets_dir = Path(__file__).parent
+for fname in os.listdir(targets_dir):
+    if not fname.endswith(".fold"):
+        continue
+    with open(targets_dir / fname) as f:
+        d = json.load(f)
+    n_v = len(d["vertices_coords"])
+    n_e = len(d["edges_vertices"])
+    assert len(d["edges_assignment"]) == n_e, f"{fname}: assignment length mismatch"
+    assert len(d["edges_foldAngle"]) == n_e, f"{fname}: foldAngle length mismatch"
+    for e in d["edges_vertices"]:
+        assert e[0] < n_v and e[1] < n_v, f"{fname}: edge references invalid vertex"
+    for face in d["faces_vertices"]:
+        for vi in face:
+            assert vi < n_v, f"{fname}: face references invalid vertex"
+    creases = [i for i,a in enumerate(d["edges_assignment"]) if a in ('M','V')]
+    print(f"{fname}: {n_v} vertices, {n_e} edges, {len(creases)} creases, level={d.get('level','?')} OK")

env/verifier.py ADDED Viewed

	@@ -0,0 +1,261 @@

+import numpy as np
+from .graph import CreaseGraph
+from .paper_state import PaperState
+def _compute_sector_angles(vertex_id: int, graph: CreaseGraph) -> list[float]:
+    """Compute consecutive sector angles (CCW) at a vertex from its cyclic edges."""
+    cyclic_edges = graph.get_cyclic_edges(vertex_id)
+    n = len(cyclic_edges)
+    vx, vy = graph.vertices[vertex_id]
+    angles = []
+    for eid in cyclic_edges:
+        ev1, ev2, _ = graph.edges[eid]
+        other_id = ev2 if ev1 == vertex_id else ev1
+        ox, oy = graph.vertices[other_id]
+        angles.append(np.arctan2(oy - vy, ox - vx))
+    sectors = []
+    for i in range(n):
+        diff = angles[(i + 1) % n] - angles[i]
+        if diff < 0:
+            diff += 2 * np.pi
+        if diff > 2 * np.pi:
+            diff -= 2 * np.pi
+        sectors.append(diff)
+    return sectors
+def check_kawasaki_at_vertex(vertex_id: int, graph: CreaseGraph) -> tuple[bool, float]:
+    """
+    Checks Kawasaki-Justin theorem at a single vertex.
+    Kawasaki: at an interior vertex with 2n creases, the alternating sum
+    of consecutive sector angles = 0.
+    Equivalently: sum(odd-indexed sectors) == sum(even-indexed sectors) == π.
+    Returns (satisfied: bool, |alternating_sum|: float).
+    Returns (True, 0.0) for vertices with degree < 4 (not an interior fold vertex yet).
+    Returns (False, inf) for odd-degree vertices (impossible for flat folds).
+    """
+    cyclic_edges = graph.get_cyclic_edges(vertex_id)
+    n = len(cyclic_edges)
+    if n % 2 != 0:
+        return (False, float('inf'))
+    if n < 4:
+        return (True, 0.0)
+    sectors = _compute_sector_angles(vertex_id, graph)
+    alt_sum = sum(s * ((-1) ** i) for i, s in enumerate(sectors))
+    return (abs(alt_sum) < 1e-9, abs(alt_sum))
+def check_maekawa_at_vertex(vertex_id: int, graph: CreaseGraph) -> bool:
+    """
+    Checks Maekawa-Justin theorem at a single vertex.
+    Maekawa: |M - V| == 2 where M, V are counts of mountain/valley fold edges
+    at the vertex. BOUNDARY edges ('B') are NOT counted.
+    Returns True if satisfied or if vertex has fewer than 4 fold edges (not yet active).
+    """
+    edge_ids = graph.vertex_edges[vertex_id]
+    fold_edges = [
+        eid for eid in edge_ids
+        if graph.edges[eid][2] in ('M', 'V')
+    ]
+    if len(fold_edges) < 4:
+        return True
+    m_count = sum(1 for eid in fold_edges if graph.edges[eid][2] == 'M')
+    v_count = sum(1 for eid in fold_edges if graph.edges[eid][2] == 'V')
+    return abs(m_count - v_count) == 2
+def check_blb_at_vertex(vertex_id: int, graph: CreaseGraph) -> list[tuple[int, int]]:
+    """
+    Checks Big-Little-Big lemma at a single vertex.
+    BLB: if sector angle i is a strict local minimum (smaller than both neighbors),
+    the fold edges bounding that sector must have OPPOSITE MV assignments.
+    Returns list of (edge_a_id, edge_b_id) pairs where BLB is violated.
+    Empty list = no violations.
+    """
+    cyclic_edges = graph.get_cyclic_edges(vertex_id)
+    n = len(cyclic_edges)
+    if n < 4:
+        return []
+    sectors = _compute_sector_angles(vertex_id, graph)
+    violations = []
+    for i in range(n):
+        prev_sector = sectors[(i - 1) % n]
+        next_sector = sectors[(i + 1) % n]
+        if sectors[i] < prev_sector and sectors[i] < next_sector:
+            edge_a = cyclic_edges[i]
+            edge_b = cyclic_edges[(i + 1) % n]
+            assign_a = graph.edges[edge_a][2]
+            assign_b = graph.edges[edge_b][2]
+            if assign_a in ('M', 'V') and assign_b in ('M', 'V'):
+                if assign_a == assign_b:
+                    violations.append((edge_a, edge_b))
+    return violations
+def _angle_diff(a1: float, a2: float) -> float:
+    """Minimum angle difference between two directed lines (considering 180° symmetry)."""
+    diff = abs(a1 - a2) % np.pi
+    return min(diff, np.pi - diff)
+def geometric_crease_coverage(
+    state: PaperState,
+    target_edges: list[dict],
+    tol_pos: float = 0.05,
+    tol_angle_deg: float = 5.0,
+) -> tuple[float, float, float]:
+    """
+    Computes how well the current crease pattern matches the target.
+    Args:
+        state: current paper state with crease graph
+        target_edges: list of {'v1': (x1,y1), 'v2': (x2,y2), 'assignment': 'M'|'V'}
+        tol_pos: position tolerance for midpoint matching
+        tol_angle_deg: angle tolerance in degrees for direction matching
+    Returns:
+        (coverage, economy, assignment_accuracy)
+        coverage: weighted fraction of target creases matched [0, 1];
+                  1.0 if position+assignment match, 0.5 if position matches but assignment doesn't
+        economy: penalty for excess creases [0, 1], 1.0 = no excess
+        assignment_accuracy: fraction of positionally matched edges that also have correct M/V assignment [0, 1];
+                            returns 1.0 if no positional matches (vacuous case)
+    """
+    current_edges = state.crease_edges()
+    tol_angle_rad = np.deg2rad(tol_angle_deg)
+    total_score = 0.0
+    position_matches = 0
+    assignment_correct = 0
+    for target in target_edges:
+        tx1, ty1 = target['v1']
+        tx2, ty2 = target['v2']
+        t_mid = ((tx1 + tx2) / 2.0, (ty1 + ty2) / 2.0)
+        t_angle = np.arctan2(ty2 - ty1, tx2 - tx1)
+        t_assign = target.get('assignment', 'M')
+        for current in current_edges:
+            cx1, cy1 = current['v1']
+            cx2, cy2 = current['v2']
+            c_mid = ((cx1 + cx2) / 2.0, (cy1 + cy2) / 2.0)
+            c_angle = np.arctan2(cy2 - cy1, cx2 - cx1)
+            c_assign = current.get('assignment', 'M')
+            mid_dist = np.hypot(c_mid[0] - t_mid[0], c_mid[1] - t_mid[1])
+            angle_distance = _angle_diff(c_angle, t_angle)
+            if mid_dist <= tol_pos and angle_distance <= tol_angle_rad:
+                position_matches += 1
+                assign_match = (t_assign == c_assign)
+                if assign_match:
+                    total_score += 1.0
+                    assignment_correct += 1
+                else:
+                    total_score += 0.5
+                break
+    coverage = total_score / max(len(target_edges), 1)
+    n_excess = max(0, len(current_edges) - len(target_edges))
+    economy = max(0.0, 1.0 - n_excess / max(len(target_edges), 1))
+    assignment_accuracy = (
+        assignment_correct / position_matches if position_matches > 0 else 1.0
+    )
+    return (coverage, economy, assignment_accuracy)
+def check_degree_sanity(graph: CreaseGraph) -> float:
+    """
+    Checks that interior vertices have even degree (required for flat-foldability).
+    Returns:
+        Fraction of interior vertices with even degree [0, 1].
+        1.0 = all interior vertices have even degree.
+        0.0 = none do.
+        Returns 1.0 if there are no interior vertices (vacuous case).
+    """
+    interior = graph.interior_vertices()
+    if not interior:
+        return 1.0
+    even_count = sum(
+        1 for vid in interior
+        if len(graph.vertex_edges[vid]) % 2 == 0
+    )
+    return even_count / len(interior)
+def check_all_vertices(graph: CreaseGraph) -> dict:
+    """
+    Run all vertex-level checks on every interior vertex.
+    Returns dict with:
+        'kawasaki': float  # fraction of interior vertices passing Kawasaki [0,1]
+        'maekawa': float   # fraction passing Maekawa [0,1]
+        'blb': float       # fraction with no BLB violations [0,1]
+        'n_interior': int  # number of interior vertices checked
+        'per_vertex': list[dict]  # per-vertex details
+    """
+    interior = graph.interior_vertices()
+    if not interior:
+        return {
+            'kawasaki': 1.0,
+            'maekawa': 1.0,
+            'blb': 1.0,
+            'n_interior': 0,
+            'per_vertex': [],
+        }
+    per_vertex = []
+    kaw_pass = 0
+    mae_pass = 0
+    blb_pass = 0
+    for vid in interior:
+        kaw_ok, kaw_val = check_kawasaki_at_vertex(vid, graph)
+        mae_ok = check_maekawa_at_vertex(vid, graph)
+        blb_violations = check_blb_at_vertex(vid, graph)
+        blb_ok = len(blb_violations) == 0
+        kaw_pass += int(kaw_ok)
+        mae_pass += int(mae_ok)
+        blb_pass += int(blb_ok)
+        per_vertex.append({
+            'vertex_id': vid,
+            'kawasaki_ok': kaw_ok,
+            'kawasaki_error': kaw_val,
+            'maekawa_ok': mae_ok,
+            'blb_violations': blb_violations,
+        })
+    n = len(interior)
+    return {
+        'kawasaki': kaw_pass / n,
+        'maekawa': mae_pass / n,
+        'blb': blb_pass / n,
+        'n_interior': n,
+        'per_vertex': per_vertex,
+    }

openenv.yaml ADDED Viewed

	@@ -0,0 +1,6 @@

+spec_version: 1
+name: optigami
+type: space
+runtime: fastapi
+app: openenv_server.app:app
+port: 8000

openenv_runtime/__init__.py ADDED Viewed

	@@ -0,0 +1,11 @@

+"""OpenEnv integration runtime for Optigami."""
+from .environment import OpenEnvOrigamiEnvironment
+from .models import OrigamiAction, OrigamiObservation, OrigamiState
+__all__ = [
+    "OpenEnvOrigamiEnvironment",
+    "OrigamiAction",
+    "OrigamiObservation",
+    "OrigamiState",
+]

openenv_runtime/environment.py ADDED Viewed

	@@ -0,0 +1,53 @@

+"""
+OpenEnv adapter for Optigami.
+Thin wrapper around env.environment.OrigamiEnvironment that adapts it to the
+OpenEnv protocol (Action/Observation types).
+"""
+from env.environment import OrigamiEnvironment as _Env
+from .models import OrigamiAction, OrigamiObservation
+class OpenEnvOrigamiEnvironment:
+    """
+    OpenEnv-compatible wrapper for env.environment.OrigamiEnvironment.
+    Converts between env's dict-based API and OpenEnv's Action/Observation types.
+    """
+    def __init__(self, mode: str = "step", max_steps: int = 8, targets_dir=None):
+        self._env = _Env(mode=mode, max_steps=max_steps, targets_dir=targets_dir)
+    def reset(self, target_name=None, **kwargs):
+        obs_dict = self._env.reset(target_name=target_name)
+        return self._obs_dict_to_model(obs_dict, reward=None, done=False)
+    def step(self, action: OrigamiAction, **kwargs):
+        action_dict = {
+            "from": action.from_point,
+            "to": action.to_point,
+            "assignment": action.assignment,
+        }
+        obs_dict, reward, done, info = self._env.step(action_dict)
+        reward_val = reward.get("total", 0.0) if isinstance(reward, dict) else reward
+        return self._obs_dict_to_model(obs_dict, reward=reward_val, done=done)
+    def _obs_dict_to_model(self, obs_dict: dict, reward=None, done=False) -> OrigamiObservation:
+        return OrigamiObservation(
+            prompt=obs_dict.get("prompt", ""),
+            target_name=obs_dict.get("target_name", ""),
+            step=obs_dict.get("step", 0),
+            paper_fold_json=obs_dict.get("paper_fold_json", {}),
+            reward=reward,
+            done=done,
+        )
+    def state(self):
+        return self._env.state()
+    def close(self):
+        self._env.close()
+__all__ = ["OpenEnvOrigamiEnvironment"]

openenv_runtime/models.py ADDED Viewed

	@@ -0,0 +1,53 @@

+"""
+OpenEnv Pydantic models for the env/ stack.
+Matches the env/environment data shape: observations with prompt, target_name,
+step, paper_fold_json; actions as fold dicts with from/to/assignment.
+"""
+from typing import Optional
+from pydantic import ConfigDict, Field
+from openenv.core.env_server.types import Action, Observation, State
+class OrigamiAction(Action):
+    """One fold operation — from_point, to_point, assignment."""
+    model_config = ConfigDict(populate_by_name=True)
+    from_point: list[float] = Field(
+        alias="from",
+        description="[x, y] start point of the crease",
+    )
+    to_point: list[float] = Field(
+        alias="to",
+        description="[x, y] end point of the crease",
+    )
+    assignment: str = Field(
+        description="'M' (mountain) or 'V' (valley)",
+    )
+class OrigamiObservation(Observation):
+    """Observation from env.environment — prompt, target, step, paper state."""
+    prompt: str = Field(default="", description="LLM prompt for the current step")
+    target_name: str = Field(default="", description="Name of the target (.fold stem)")
+    step: int = Field(default=0, ge=0, description="Current step index")
+    paper_fold_json: dict = Field(
+        default_factory=dict,
+        description="Graph edges (crease pattern state)",
+    )
+class OrigamiState(State):
+    """Server-side episode state."""
+    paper: dict = Field(default_factory=dict, description="Paper state")
+    target: Optional[str] = Field(default=None, description="Target name")
+    step: int = Field(default=0, ge=0, description="Step count")
+    mode: str = Field(default="step", description="'step' or 'code_as_policy'")
+__all__ = ["OrigamiAction", "OrigamiObservation", "OrigamiState"]

openenv_server/__init__.py ADDED Viewed

	@@ -0,0 +1 @@


1	+ """OpenEnv FastAPI app package."""

openenv_server/app.py ADDED Viewed

	@@ -0,0 +1,269 @@

+from __future__ import annotations
+import asyncio
+import json
+from pathlib import Path
+import numpy as np
+from fastapi import HTTPException, WebSocket
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from openenv.core.env_server.http_server import create_app
+from env.environment import OrigamiEnvironment
+from openenv_runtime.environment import OpenEnvOrigamiEnvironment
+from openenv_runtime.models import OrigamiAction, OrigamiObservation
+from server.training_broadcast import TrainingBroadcastServer
+# ---------------------------------------------------------------------------
+# Numpy-safe JSON response
+# ---------------------------------------------------------------------------
+def _np_default(obj):
+    if isinstance(obj, np.bool_):
+        return bool(obj)
+    if isinstance(obj, np.integer):
+        return int(obj)
+    if isinstance(obj, np.floating):
+        return float(obj)
+    if isinstance(obj, np.ndarray):
+        return obj.tolist()
+    raise TypeError(f"Not serializable: {type(obj)}")
+class NumpyJSONResponse(JSONResponse):
+    def render(self, content) -> bytes:
+        return json.dumps(content, default=_np_default).encode("utf-8")
+# ---------------------------------------------------------------------------
+# Episode registry for replay
+# ---------------------------------------------------------------------------
+_episode_registry: dict[str, dict] = {}
+# ---------------------------------------------------------------------------
+# OpenEnv app + training broadcast server
+# ---------------------------------------------------------------------------
+app = create_app(
+    env=lambda: OpenEnvOrigamiEnvironment(mode="step"),
+    action_cls=OrigamiAction,
+    observation_cls=OrigamiObservation,
+    env_name="optigami",
+)
+broadcast = TrainingBroadcastServer()
+def _ensure_broadcast_loop():
+    """Set broadcast loop on first use (replaces deprecated on_event('startup'))."""
+    if broadcast._loop is None or broadcast._loop.is_closed():
+        try:
+            broadcast._loop = asyncio.get_running_loop()
+        except RuntimeError:
+            pass
+@app.middleware("http")
+async def _set_broadcast_loop(request, call_next):
+    """Ensure broadcast has event loop before handling requests."""
+    _ensure_broadcast_loop()
+    return await call_next(request)
+# ---------------------------------------------------------------------------
+# Health endpoint
+# ---------------------------------------------------------------------------
+@app.get("/health", include_in_schema=True)
+async def health():
+    return {"status": "ok"}
+# ---------------------------------------------------------------------------
+# Episode replay endpoint
+# ---------------------------------------------------------------------------
+@app.get("/episode/replay/{ep_id}", include_in_schema=True, response_class=NumpyJSONResponse)
+async def replay_episode(ep_id: str):
+    if ep_id not in _episode_registry:
+        raise HTTPException(status_code=404, detail="Episode not found")
+    return NumpyJSONResponse(_episode_registry[ep_id])
+# ---------------------------------------------------------------------------
+# Training grid viewer WebSocket
+# ---------------------------------------------------------------------------
+@app.websocket("/ws/training")
+async def training_ws(websocket: WebSocket):
+    """Read-only spectator WebSocket for the training grid viewer."""
+    _ensure_broadcast_loop()
+    await broadcast.connect_spectator(websocket)
+# ---------------------------------------------------------------------------
+# Helper: extract crease folds from .fold target
+# ---------------------------------------------------------------------------
+def _target_to_folds(target: dict) -> list[dict]:
+    """Extract crease folds from a target .fold dict (edges with M or V)."""
+    verts = target.get("vertices_coords", [])
+    edges_v = target.get("edges_vertices", [])
+    edges_a = target.get("edges_assignment", [])
+    folds = []
+    for (v1, v2), ass in zip(edges_v, edges_a):
+        if ass in ("M", "V") and v1 < len(verts) and v2 < len(verts):
+            p1 = verts[v1]
+            p2 = verts[v2]
+            folds.append({"from": p1, "to": p2, "assignment": ass})
+    return folds
+def _graph_state_to_fold(paper_dict: dict) -> dict:
+    """Convert internal graph state dict to FOLD-format arrays for the frontend.
+    Input format (from env.state()['paper']):
+        vertices: {id: (x, y), ...}
+        edges: {id: (v1_id, v2_id, assignment), ...}  (only M/V)
+    Output format (FOLD):
+        vertices_coords: [[x, y, 0], ...]
+        edges_vertices: [[i, j], ...]
+        edges_assignment: ['M'|'V'|'B', ...]
+        faces_vertices: [[i, j, k], ...]  (Delaunay triangulation for 3D)
+    """
+    raw_verts = paper_dict.get("vertices", {})
+    raw_edges = paper_dict.get("edges", {})
+    if not raw_verts:
+        return {}
+    sorted_ids = sorted(raw_verts.keys(), key=lambda k: int(k) if isinstance(k, (int, str)) else k)
+    id_to_idx = {vid: idx for idx, vid in enumerate(sorted_ids)}
+    vertices_coords = []
+    for vid in sorted_ids:
+        xy = raw_verts[vid]
+        vertices_coords.append([float(xy[0]), float(xy[1]), 0.0])
+    edges_vertices = []
+    edges_assignment = []
+    for eid in sorted(raw_edges.keys(), key=lambda k: int(k) if isinstance(k, (int, str)) else k):
+        v1_id, v2_id, asgn = raw_edges[eid]
+        if v1_id in id_to_idx and v2_id in id_to_idx:
+            edges_vertices.append([id_to_idx[v1_id], id_to_idx[v2_id]])
+            edges_assignment.append(asgn)
+    faces_vertices = _triangulate_vertices(vertices_coords)
+    return {
+        "vertices_coords": vertices_coords,
+        "edges_vertices": edges_vertices,
+        "edges_assignment": edges_assignment,
+        "faces_vertices": faces_vertices,
+    }
+def _triangulate_vertices(vertices_coords: list) -> list:
+    """Delaunay triangulate the 2D vertex set for 3D mesh rendering."""
+    if len(vertices_coords) < 3:
+        return []
+    try:
+        from scipy.spatial import Delaunay
+        pts = np.array([[v[0], v[1]] for v in vertices_coords])
+        tri = Delaunay(pts)
+        return tri.simplices.tolist()
+    except Exception:
+        return [[0, 1, 2], [0, 2, 3]] if len(vertices_coords) >= 4 else []
+# ---------------------------------------------------------------------------
+# API routes — must be registered BEFORE the StaticFiles catch-all mount
+# ---------------------------------------------------------------------------
+@app.get("/targets", include_in_schema=True, response_class=NumpyJSONResponse)
+def get_targets():
+    """Return available target names and metadata from env/targets/*.fold."""
+    env = OrigamiEnvironment()
+    names = env.available_targets()
+    result: dict[str, dict] = {}
+    for name in names:
+        target = env._targets.get(name, {})
+        result[name] = {
+            "name": name,
+            "level": target.get("level", 1),
+            "description": target.get("description", ""),
+            "n_creases": len([a for a in target.get("edges_assignment", []) if a in ("M", "V")]),
+            "difficulty": target.get("level", 1),
+            "material": "paper",
+        }
+    return NumpyJSONResponse(result)
+@app.get("/episode/demo", include_in_schema=True, response_class=NumpyJSONResponse)
+def demo_episode(target: str = "half_horizontal"):
+    """Return a pre-solved demo episode for the given .fold target."""
+    env = OrigamiEnvironment(mode="step")
+    targets = env.available_targets()
+    if target not in targets:
+        target = targets[0] if targets else "half_horizontal"
+    t = env._targets.get(target, {})
+    folds = _target_to_folds(t)
+    obs_dict = env.reset(target_name=target)
+    steps: list[dict] = []
+    for i, fold_dict in enumerate(folds):
+        obs_dict, reward, done, info = env.step(fold_dict)
+        graph = env.paper.graph
+        all_edges = {eid: (v1, v2, a) for eid, (v1, v2, a) in graph.edges.items()}
+        fold_state = _graph_state_to_fold({
+            "vertices": dict(graph.vertices),
+            "edges": all_edges,
+        })
+        steps.append({
+            "step": i + 1,
+            "fold": fold_dict,
+            "paper_state": fold_state,
+            "metrics": reward if isinstance(reward, dict) else {"total": reward},
+            "done": done,
+        })
+        if done:
+            break
+    return NumpyJSONResponse({
+        "task_name": target,
+        "task": {"name": target, "level": t.get("level", 1), "description": t.get("description", "")},
+        "target_crease": t,
+        "steps": steps,
+        "final_metrics": steps[-1]["metrics"] if steps else {},
+    })
+# ---------------------------------------------------------------------------
+# Static file serving — must come LAST so API routes take priority
+# ---------------------------------------------------------------------------
+_BUILD_DIR = Path(__file__).resolve().parent.parent / "build"
+if _BUILD_DIR.exists():
+    app.mount("/", StaticFiles(directory=str(_BUILD_DIR), html=True), name="renderer")
+else:
+    @app.get("/", include_in_schema=False)
+    def missing_renderer_build() -> HTMLResponse:
+        return HTMLResponse(
+            """
+            <html><body style="font-family: sans-serif; margin: 24px;">
+            <h3>Renderer build not found</h3>
+            <p>No <code>build/</code> directory is present in the container.</p>
+            <p>OpenEnv API docs are available at <a href="/docs">/docs</a>.</p>
+            </body></html>
+            """,
+            status_code=200,
+        )

package-lock.json ADDED Viewed

The diff for this file is too large to render. See raw diff

package.json CHANGED Viewed

@@ -24,6 +24,7 @@
       "react-app/jest"
     ]
   },
   "browserslist": {
     "production": [
       ">0.2%",

       "react-app/jest"
     ]
   },
+  "proxy": "http://localhost:7860",
   "browserslist": {
     "production": [
       ">0.2%",

planner/decomposer.py DELETED Viewed

@@ -1,284 +0,0 @@
-"""
-Task decomposer: breaks a parsed instruction into sequential sub-goals
-with concrete fold operations on a unit square.
-"""
-from __future__ import annotations
-import copy
-from planner.knowledge import (
-    ORIGAMI_MODELS,
-    ORIGAMI_BASES,
-    FOLD_OPERATIONS,
-    get_model_steps,
-    get_base_steps,
-)
-# ---------------------------------------------------------------------------
-# Internal helpers
-# ---------------------------------------------------------------------------
-def _step_to_fold_operation(step: dict) -> dict:
-    """
-    Convert a knowledge-base step dict into the engine's fold operation format:
-      {"type": ..., "line": {"start": [...], "end": [...]}, "angle": ...}
-    """
-    op = {
-        "type": step["type"],
-        "line": copy.deepcopy(step["line"]),
-        "angle": step.get("angle", 180),
-    }
-    if "layer_select" in step:
-        op["layer_select"] = step["layer_select"]
-    return op
-def _expected_state_after_fold(fold_type: str, prev_state: dict | None) -> dict:
-    """
-    Produce a lightweight expected-state dict describing what the paper
-    should look like after a fold.  This is intentionally approximate --
-    the real simulation engine computes exact geometry.
-    """
-    state = dict(prev_state or {"layers": 1, "shape": "square", "phase": "flat"})
-    if fold_type in ("valley", "mountain"):
-        state["layers"] = state.get("layers", 1) * 2
-    elif fold_type == "petal":
-        state["shape"] = "narrow_diamond"
-    elif fold_type == "squash":
-        state["shape"] = "diamond"
-    elif fold_type == "reverse_inside":
-        state["shape"] = "pointed_flap_reversed"
-    elif fold_type == "inflate":
-        state["phase"] = "3d"
-    elif fold_type == "turn_over":
-        state["flipped"] = not state.get("flipped", False)
-    elif fold_type == "unfold":
-        # Layers don't literally halve on every unfold, but this is a hint
-        state["layers"] = max(1, state.get("layers", 1) // 2)
-    return state
-def _validation_for_fold(fold_type: str) -> dict:
-    """Return a simple validation dict for a step."""
-    checks: dict = {"flat_foldable": True}
-    if fold_type in ("valley", "mountain"):
-        checks["kawasaki_check"] = True
-        checks["maekawa_check"] = True
-    if fold_type == "inflate":
-        checks["is_3d"] = True
-        checks["flat_foldable"] = False
-    return checks
-# ---------------------------------------------------------------------------
-# Known-model decomposition
-# ---------------------------------------------------------------------------
-def _decompose_known_model(parsed: dict) -> list[dict]:
-    """Decompose a known model into sub-goal steps."""
-    model_name: str = parsed["model_name"]
-    model_info = ORIGAMI_MODELS.get(model_name)
-    if model_info is None:
-        return _decompose_free_fold(parsed)
-    base_name = model_info.get("base")
-    steps = get_model_steps(model_name)
-    sub_goals: list[dict] = []
-    running_state: dict = {"layers": 1, "shape": "square", "phase": "flat"}
-    for i, step in enumerate(steps):
-        fold_op = _step_to_fold_operation(step)
-        running_state = _expected_state_after_fold(step["type"], running_state)
-        sub_goals.append({
-            "step_number": i + 1,
-            "description": step.get("description", f"Step {i + 1}"),
-            "base_required": base_name if i == 0 else None,
-            "fold_operations": [fold_op],
-            "expected_state": dict(running_state),
-            "validation": _validation_for_fold(step["type"]),
-        })
-    return sub_goals
-# ---------------------------------------------------------------------------
-# Packing / optimization decomposition
-# ---------------------------------------------------------------------------
-def _decompose_packing(parsed: dict) -> list[dict]:
-    """
-    Decompose an optimize_packing task into sub-goals.
-    Returns a Miura-ori-style fold plan on a unit square.
-    """
-    w = parsed["dimensions"]["width"]
-    h = parsed["dimensions"]["height"]
-    material = parsed["material"]
-    constraints = parsed.get("constraints", {})
-    max_folds = constraints.get("max_folds", 20)
-    sub_goals: list[dict] = []
-    step_num = 0
-    # Horizontal valley/mountain pleats (zigzag in Y)
-    n_horizontal = min(4, max_folds // 4)
-    spacing_y = 1.0 / (n_horizontal + 1)
-    for i in range(n_horizontal):
-        step_num += 1
-        y = spacing_y * (i + 1)
-        fold_type = "valley" if i % 2 == 0 else "mountain"
-        sub_goals.append({
-            "step_number": step_num,
-            "description": f"Horizontal {fold_type} fold at y={y:.3f} (pleat {i + 1}/{n_horizontal})",
-            "base_required": None,
-            "fold_operations": [{
-                "type": fold_type,
-                "line": {"start": [0.0, y], "end": [1.0, y]},
-                "angle": 180,
-                "layer_select": "all",
-            }],
-            "expected_state": {"layers": i + 2, "phase": "flat", "pattern": "miura_horizontal"},
-            "validation": {"flat_foldable": True, "kawasaki_check": True},
-        })
-    # Vertical zigzag valley/mountain pleats (Miura-ori angle offsets)
-    n_vertical = min(4, (max_folds - n_horizontal) // 2)
-    spacing_x = 1.0 / (n_vertical + 1)
-    for i in range(n_vertical):
-        step_num += 1
-        x = spacing_x * (i + 1)
-        fold_type = "valley" if i % 2 == 0 else "mountain"
-        # Miura-ori: alternate slight angle offset to create parallelogram cells
-        angle_offset = 0.02 * (1 if i % 2 == 0 else -1)
-        sub_goals.append({
-            "step_number": step_num,
-            "description": f"Vertical {fold_type} fold at x={x:.3f} (Miura-ori column {i + 1}/{n_vertical})",
-            "base_required": None,
-            "fold_operations": [{
-                "type": fold_type,
-                "line": {"start": [x, 0.0 + angle_offset], "end": [x, 1.0 - angle_offset]},
-                "angle": 180,
-                "layer_select": "all",
-            }],
-            "expected_state": {
-                "layers": (n_horizontal + 1) * (i + 2),
-                "phase": "flat",
-                "pattern": "miura_complete" if i == n_vertical - 1 else "miura_partial",
-            },
-            "validation": {"flat_foldable": True, "kawasaki_check": True, "maekawa_check": True},
-        })
-    # Final collapse
-    step_num += 1
-    sub_goals.append({
-        "step_number": step_num,
-        "description": "Collapse all creases simultaneously into compact Miura-ori stack",
-        "base_required": None,
-        "fold_operations": [{
-            "type": "valley",
-            "line": {"start": [0.0, 0.5], "end": [1.0, 0.5]},
-            "angle": 180,
-            "layer_select": "all",
-        }],
-        "expected_state": {
-            "layers": (n_horizontal + 1) * (n_vertical + 1),
-            "phase": "compact",
-            "pattern": "miura_ori",
-        },
-        "validation": {
-            "flat_foldable": True,
-            "check_bounding_box": constraints.get("target_box"),
-            "check_deployable": constraints.get("must_deploy", False),
-        },
-    })
-    return sub_goals
-# ---------------------------------------------------------------------------
-# Free-fold / unknown model decomposition
-# ---------------------------------------------------------------------------
-def _decompose_free_fold(parsed: dict) -> list[dict]:
-    """
-    Generic decomposition for an unknown model or free-form folding task.
-    Returns a minimal plan that an LLM can expand upon.
-    """
-    return [
-        {
-            "step_number": 1,
-            "description": "Create reference creases (diagonals and midlines)",
-            "base_required": None,
-            "fold_operations": [
-                {"type": "valley", "line": {"start": [0.0, 0.0], "end": [1.0, 1.0]}, "angle": 180},
-                {"type": "unfold", "line": {"start": [0.0, 0.0], "end": [1.0, 1.0]}, "angle": 0},
-                {"type": "valley", "line": {"start": [1.0, 0.0], "end": [0.0, 1.0]}, "angle": 180},
-                {"type": "unfold", "line": {"start": [1.0, 0.0], "end": [0.0, 1.0]}, "angle": 0},
-                {"type": "valley", "line": {"start": [0.0, 0.5], "end": [1.0, 0.5]}, "angle": 180},
-                {"type": "unfold", "line": {"start": [0.0, 0.5], "end": [1.0, 0.5]}, "angle": 0},
-            ],
-            "expected_state": {"layers": 1, "shape": "square", "phase": "creased"},
-            "validation": {"flat_foldable": True},
-        },
-        {
-            "step_number": 2,
-            "description": "Collapse into a base form using reference creases",
-            "base_required": "preliminary_base",
-            "fold_operations": [
-                {"type": "valley", "line": {"start": [0.0, 0.0], "end": [1.0, 1.0]}, "angle": 180, "layer_select": "all"},
-            ],
-            "expected_state": {"layers": 4, "shape": "diamond", "phase": "base"},
-            "validation": {"flat_foldable": True},
-        },
-        {
-            "step_number": 3,
-            "description": "Shape the model with additional folds (LLM determines specifics)",
-            "base_required": None,
-            "fold_operations": [],  # Left empty for LLM to fill
-            "expected_state": {"phase": "shaped"},
-            "validation": {"flat_foldable": True},
-        },
-    ]
-# ---------------------------------------------------------------------------
-# Fold-pattern decomposition
-# ---------------------------------------------------------------------------
-def _decompose_pattern(parsed: dict) -> list[dict]:
-    """Decompose a tessellation/pattern task."""
-    # For now, delegate to packing which generates a Miura-ori pattern
-    return _decompose_packing(parsed)
-# ---------------------------------------------------------------------------
-# Public API
-# ---------------------------------------------------------------------------
-def decompose_task(parsed: dict) -> list[dict]:
-    """
-    Decompose a parsed instruction into sequential sub-goals.
-    Args:
-        parsed: Output of parse_instruction()
-    Returns:
-        List of sub-goal dicts, each with:
-          - step_number: int
-          - description: str
-          - base_required: str or None
-          - fold_operations: list[dict]  (engine-format fold dicts)
-          - expected_state: dict
-          - validation: dict
-    """
-    intent = parsed.get("intent", "free_fold")
-    if intent == "fold_model" and parsed.get("model_name"):
-        return _decompose_known_model(parsed)
-    elif intent == "optimize_packing":
-        return _decompose_packing(parsed)
-    elif intent == "fold_pattern":
-        return _decompose_pattern(parsed)
-    else:
-        return _decompose_free_fold(parsed)