diff --git a/packages/app/next.config.ts b/packages/app/next.config.ts index 4023a9c..0f1aa0e 100644 --- a/packages/app/next.config.ts +++ b/packages/app/next.config.ts @@ -5,6 +5,13 @@ const nextConfig: NextConfig = { experimental: { optimizePackageImports: ['@fluentui/react-components'], }, + async rewrites() { + return { + beforeFiles: [ + { source: '/', destination: '/marketing.html' }, + ], + }; + }, }; export default nextConfig; diff --git a/packages/app/public/marketing.html b/packages/app/public/marketing.html new file mode 100644 index 0000000..f638278 --- /dev/null +++ b/packages/app/public/marketing.html @@ -0,0 +1,815 @@ + + +
+ + ++ The first canvas where every artboard is a live render of your actual app — and every edit is a code diff. +
+ + + + +Your design file and your codebase diverge the moment you ship. Every handoff creates a gap. Every gap creates debt.
+Design files describe pixels. Code describes behaviour. Neither speaks the other's language — designers spec what they imagine, engineers ship what they can build in time.
+Switch from Figma to your editor and every annotation, constraint, and decision stays behind. Context collapses into a Slack thread that nobody reads twice.
+AI tools generate strangers. v0 produces components your design system doesn't recognise. The blank canvas ignores all the decisions already encoded in your app.
+Each feature removes a seam between design intent and production code.
+A live render of your actual application — not a mockup. Every artboard is backed by a real component tree running your real code.
+Every artboard traces its provenance through a queryable graph. Know exactly which files, props, and tokens compose each surface.
+Visual changes expressed at the component level, not the pixel level. Ship diffs that say "increase Card border-radius" — not a PNG redline.
+Mark a region. AI fills it within your design language constraints — using your actual tokens, your actual components, nothing invented.
+Bidirectional MCP channel between your design surface and coding agents. Claude, Cursor, Copilot — they all see the canvas and the graph simultaneously.
+Point Originmain at your repo. The Origin Graph indexes your components, tokens, and routes.
+Open any route as a live artboard. Every visual change is a real prop or style edit.
+Mark a region and let AI suggest completions constrained to your existing design language.
+Export an Intent Diff — a machine-readable component-level description of what changed.
+Agents apply the diff and verify rendering parity. The canvas confirms the result.
+Slots into the tools you already use. No migration required.
+Existing tools solve half the problem. Originmain closes the loop.
+Figma is the best interface design tool ever made — but what you design is a fiction. It has no knowledge of your codebase, tokens, or component API surface. The handoff is manual, lossy, and perpetually stale.
+ +Every artboard is a live render. Every edit writes code. The gap between design and production is zero — because they're the same surface, indexed by the same graph.
+ +v0 and Cursor are exceptional at generating code from a blank slate — but they hallucinate design systems. They don't know your tokens, your component API, or what "on-brand" means for your product.
+ +The ideal design tool is a canvas where any view of your application can be rendered, explored, duplicated, and modified visually — with every change traced back to a diff in your actual codebase.
+Early access is free. All plans include the full Origin Graph and Live Artboard engine.
+