@sequenceholdings/artifact-studio 0.1.0

package/dist/paths.d.ts

@@ -0,0 +1,6 @@
+export declare const MAX_STUDIO_PATH_LENGTH = 512;
+export declare class InvalidArtifactPathError extends Error {
+    constructor(message: string);
+}
+export declare function normalizeArtifactPath(path: string): string;
+export declare function validateArtifactPath(path: string): void;

package/dist/paths.js

@@ -0,0 +1,34 @@
+export const MAX_STUDIO_PATH_LENGTH = 512;
+const WINDOWS_DRIVE_RE = /^[a-zA-Z]:[\\/]/;
+const CONTROL_CHAR_RE = /[\x00-\x1f]/;
+export class InvalidArtifactPathError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidArtifactPathError';
+    }
+}
+export function normalizeArtifactPath(path) {
+    const normalized = path.replace(/\\/g, '/').trim();
+    validateArtifactPath(normalized);
+    return normalized;
+}
+export function validateArtifactPath(path) {
+    if (!path)
+        throw new InvalidArtifactPathError('path cannot be empty');
+    if (path.length > MAX_STUDIO_PATH_LENGTH) {
+        throw new InvalidArtifactPathError(`path exceeds ${MAX_STUDIO_PATH_LENGTH} characters`);
+    }
+    if (path.startsWith('/'))
+        throw new InvalidArtifactPathError('absolute paths are not allowed');
+    if (WINDOWS_DRIVE_RE.test(path))
+        throw new InvalidArtifactPathError('Windows drive paths are not allowed');
+    if (CONTROL_CHAR_RE.test(path))
+        throw new InvalidArtifactPathError('control characters are not allowed in paths');
+    const segments = path.split('/');
+    if (segments.some((segment) => !segment || segment === '.' || segment === '..')) {
+        throw new InvalidArtifactPathError('path segments cannot be empty, ".", or ".."');
+    }
+    if (segments.includes('node_modules')) {
+        throw new InvalidArtifactPathError('node_modules cannot be included in artifact source');
+    }
+}

package/dist/project.d.ts

@@ -0,0 +1,14 @@
+import { type ArtifactStudioManifest } from './manifest.js';
+export interface ArtifactStudioSourceFile {
+    path: string;
+    content: string;
+    contentType: string;
+}
+export interface ArtifactStudioSource {
+    root: string;
+    manifest: ArtifactStudioManifest;
+    files: ArtifactStudioSourceFile[];
+    sourceHash: string;
+}
+export declare function hasArtifactStudioManifest(rootDir: string): boolean;
+export declare function readArtifactStudioSource(rootDir: string): Promise<ArtifactStudioSource>;

package/dist/project.js

@@ -0,0 +1,76 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import yaml from 'js-yaml';
+import { computeSourceHash } from './hash.js';
+import { parseArtifactStudioManifest } from './manifest.js';
+import { normalizeArtifactPath } from './paths.js';
+const IGNORED_DIRS = new Set(['node_modules', '.git', 'dist', '.next', '.artifact-studio']);
+const TEXT_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.json', '.css', '.html', '.md', '.yml', '.yaml', '.svg',
+]);
+export function hasArtifactStudioManifest(rootDir) {
+    return existsSync(join(resolve(rootDir), 'artifact.bundle.yml'));
+}
+export async function readArtifactStudioSource(rootDir) {
+    const root = resolve(rootDir);
+    const rawManifest = yaml.load(await readFile(join(root, 'artifact.bundle.yml'), 'utf8'));
+    const manifest = parseArtifactStudioManifest(rawManifest);
+    const files = await collectSourceFiles(root);
+    if (!files.some((file) => file.path === manifest.artifact.entrypoint)) {
+        throw new Error(`Entrypoint file not found: ${manifest.artifact.entrypoint}`);
+    }
+    return {
+        root,
+        manifest,
+        files,
+        sourceHash: computeSourceHash({ files, manifest }),
+    };
+}
+async function collectSourceFiles(root) {
+    const files = [];
+    async function walk(dir) {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const absolute = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (!IGNORED_DIRS.has(entry.name))
+                    await walk(absolute);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const path = normalizeArtifactPath(relative(root, absolute));
+            if (!isTextFile(path))
+                continue;
+            files.push({
+                path,
+                content: await readFile(absolute, 'utf8'),
+                contentType: inferContentType(path),
+            });
+        }
+    }
+    await walk(root);
+    return files.sort((a, b) => a.path.localeCompare(b.path));
+}
+function isTextFile(path) {
+    const ext = path.includes('.') ? path.slice(path.lastIndexOf('.')) : '';
+    return path === 'artifact.bundle.yml' || TEXT_EXTENSIONS.has(ext);
+}
+function inferContentType(path) {
+    if (path.endsWith('.tsx') || path.endsWith('.ts'))
+        return 'text/typescript';
+    if (path.endsWith('.jsx') || path.endsWith('.js'))
+        return 'text/javascript';
+    if (path.endsWith('.css'))
+        return 'text/css';
+    if (path.endsWith('.json'))
+        return 'application/json';
+    if (path.endsWith('.yml') || path.endsWith('.yaml'))
+        return 'text/yaml';
+    if (path.endsWith('.html'))
+        return 'text/html';
+    if (path.endsWith('.svg'))
+        return 'image/svg+xml';
+    return 'text/plain';
+}

package/dist/sdk.d.ts

@@ -0,0 +1,60 @@
+export interface SequenceApiFetchOptions {
+    method?: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+}
+export interface SequenceApiFetchResponse<TBody = unknown> {
+    ok: boolean;
+    status: number;
+    body: TBody;
+}
+export interface SequenceApi {
+    fetch<TBody = unknown>(path: string, options?: SequenceApiFetchOptions): Promise<SequenceApiFetchResponse<TBody>>;
+    stream(path: string, options?: SequenceApiFetchOptions): Promise<ReadableStream<Uint8Array>>;
+    get<TBody = unknown>(path: string): Promise<TBody>;
+    post<TBody = unknown>(path: string, body?: unknown): Promise<TBody>;
+    put<TBody = unknown>(path: string, body?: unknown): Promise<TBody>;
+    patch<TBody = unknown>(path: string, body?: unknown): Promise<TBody>;
+    delete<TBody = unknown>(path: string, body?: unknown): Promise<TBody>;
+}
+export interface SequenceFunctions {
+    invoke<TOutput = unknown>(id: string, params?: Record<string, unknown>): Promise<TOutput>;
+}
+export interface SequenceUser {
+    current(): Promise<{
+        email: string;
+        name: string;
+        id: string;
+    }>;
+}
+export interface SequenceEnvironment {
+    current(): Promise<{
+        name: string;
+        url: string;
+    }>;
+}
+export interface SequenceAuth {
+    hasPermission(permission: string): Promise<boolean>;
+    getPermissions(): Promise<string[]>;
+}
+export interface SequenceFlags {
+    isEnabled(flagName: string): Promise<boolean>;
+}
+export interface SequenceArtifactSdk {
+    api: SequenceApi;
+    ai: {
+        fetch(path: string, options?: SequenceApiFetchOptions): Promise<Response>;
+    };
+    functions: SequenceFunctions;
+    user: SequenceUser;
+    env: SequenceEnvironment;
+    auth: SequenceAuth;
+    flags: SequenceFlags;
+}
+declare global {
+    interface Window {
+        seq: SequenceArtifactSdk;
+    }
+}
+export declare const seq: SequenceArtifactSdk;
+export default seq;

package/dist/sdk.js

@@ -0,0 +1,4 @@
+export const seq = typeof window !== 'undefined'
+    ? window.seq
+    : undefined;
+export default seq;

package/dist/templates/react-vite/CLAUDE.md

@@ -0,0 +1,55 @@
+# Sequence Artifact Studio app
+
+This is a sandboxed iframe SPA that runs inside Atlas and talks to Atlas backend routes through a postMessage bridge exposed as `seq.api.*` from `@sequenceholdings/artifact-studio`. No direct network access, no API keys in the bundle — everything goes through the bridge, and every endpoint the artifact uses must be declared in `artifact.bundle.yml`.
+
+## Three rules that bite
+
+1. **Envelope unwrap.** Atlas wraps every CRM-style response in `{ success: true, data: T }`. The bridge passes that envelope through raw — it does **not** unwrap automatically. Route every read/write through `unwrap<T>()` in `src/lib/api.ts`:
+   ```ts
+   import { unwrap, seq } from './lib/api'
+   const customer = await unwrap<Customer>(seq.api.get(`/api/crm/customers/${id}`))
+   ```
+   For endpoints with extra envelope fields (pagination `meta`, warnings), drop to `seq.api.fetch` and read `res.body` directly.
+
+2. **FormData blocker.** `seq.api.fetch` `JSON.stringify`s any non-string `body` value, which silently turns `FormData` into `"{}"`. For uploads, base64-encode the bytes and POST as JSON, or patch the Atlas bridge first.
+
+3. **Capability matcher: exact path or `/*` prefix wildcard only.** `{id}` template forms do **not** match. List both the bare path and the prefix wildcard in `artifact.bundle.yml`:
+   ```yaml
+   - /api/crm/customers
+   - /api/crm/customers/*
+   ```
+
+## Prerequisite
+
+`artifact-studio init` requires the Sequence monorepo checked out locally. The CLI rewrites `"@sequenceholdings/atlas-ui": "workspace:*"` and the `@sequenceholdings/artifact-studio` entry in this `package.json` to local `link:` paths against the monorepo's `shared/services/atlas-ui` and `shared/services/artifact-studio`. Without the monorepo the rewrite no-ops, and `pnpm install` then fails on the unresolved `workspace:*` — those two packages aren't published to the public npm registry yet. Run init from inside the monorepo, e.g. `pnpm --dir atlas artifact-studio init <dir>`.
+
+## Package manager: pnpm
+
+This scaffold declares `"packageManager": "pnpm@10.28.2"` and the CLI writes both `@sequenceholdings/atlas-ui` and `@sequenceholdings/artifact-studio` as **`link:` deps** (not `file:`). `link:` is pnpm-specific: it tells pnpm to symlink the package without re-resolving its transitive `workspace:*` deps. That matters because the linked `@sequenceholdings/artifact-studio` package still carries `"@sequenceholdings/atlas-ui": "workspace:*"` in its own `package.json`; with `file:` pnpm would try to resolve that protocol against the standalone scaffold and fail with `ERR_PNPM_WORKSPACE_PKG_NOT_FOUND`. Always `pnpm install` — npm doesn't understand `link:`.
+
+## Key files
+
+| File | Role |
+|---|---|
+| `artifact.bundle.yml` | Capability manifest — every API path the artifact calls, exact + `/*` |
+| `src/main.tsx` | Providers: `QueryClientProvider` → `PortalContainerProvider` → `App` |
+| `src/App.tsx` | Entrypoint UI |
+| `src/lib/api.ts` | `unwrap<T>` envelope helper + re-export of `seq` |
+| `src/styles.css` | Tailwind v4 + `@sequenceholdings/atlas-ui/tokens.css` |
+| `vite.config.ts` | Vite + React + Tailwind v4 plugin |
+
+## Defaults
+
+- UI: prefer `@sequenceholdings/atlas-ui` primitives (`Button`, `Card`, `Input`, `Dialog`, `KpiTile`, `Switch`, …) over raw Tailwind. `Select`, `Checkbox`, and `DropdownMenu` are not exported — use native `<select>`, `Switch`, and `Popover` respectively.
+- Routing: `HashRouter`. Mount routes at `/`, not at the Atlas app prefix.
+- Data: React Query is wired in `src/main.tsx`. Use `useQuery` / `useMutation` against `unwrap(seq.api.*)`.
+- Icons: do **not** install `@tabler/icons-react` — it won't resolve from the artifact's local `node_modules`. Inline SVG components in `src/icons.tsx`.
+
+## Bridge methods
+
+Two primitives on `seq.api`:
+
+- `seq.api.fetch(path, options?)` returns `{ ok, status, body }` — does not throw on non-2xx. Use when you need the status (e.g. handle 409) or the raw envelope with extra fields like `meta`.
+- `seq.api.request(method, path, body?)` throws on non-2xx and returns parsed JSON. Sugar wrappers `seq.api.get / .post / .patch / .delete` are thin shells around `request`, so they also throw.
+
+Wrap reads/writes that should auto-throw through `unwrap()` in `src/lib/api.ts`. Drop to `seq.api.fetch` when you need pagination `meta` or status inspection.

package/dist/templates/react-vite/artifact.bundle.yml

@@ -0,0 +1,30 @@
+bundle:
+  name: {{slug}}
+  schema_version: 1
+
+artifact:
+  project_id: {{slug}}
+  title: "{{title}}"
+  description: "A Git-backed Artifact Studio app"
+  type: react
+  entrypoint: src/App.tsx
+
+runtime:
+  sdk: sequence
+  react: 18
+
+capabilities:
+  data:
+    read: []
+    write: []
+  api:
+    read:
+      - /api/health
+    write: []
+  functions:
+    invoke: []
+
+targets:
+  staging:
+    url: https://staging.atlas.seqholdings.com
+    visibility: private

package/dist/templates/react-vite/index.html

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

package/dist/templates/react-vite/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "{{slug}}",
+  "private": true,
+  "type": "module",
+  "packageManager": "pnpm@10.28.2",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@sequenceholdings/artifact-studio": "workspace:*",
+    "@sequenceholdings/atlas-ui": "workspace:*",
+    "@tanstack/react-query": "^4.36.1",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4.2.2",
+    "@tailwindcss/vite": "^4.2.2",
+    "@vitejs/plugin-react": "^5.0.0",
+    "tailwindcss": "^4.2.2",
+    "tw-animate-css": "^1.4.0",
+    "typescript": "^5.6.0",
+    "vite": "8.0.8"
+  }
+}

package/dist/templates/react-vite/src/App.tsx

@@ -0,0 +1,54 @@
+import { seq } from '@sequenceholdings/artifact-studio'
+import {
+  Button,
+  Card,
+  CardHeader,
+  CardTitle,
+  CardContent,
+  Badge,
+} from '@sequenceholdings/atlas-ui'
+
+const CARDS = [
+  { label: 'Source model', value: 'Vite React' },
+  { label: 'Runtime', value: 'Atlas iframe' },
+  { label: 'Release mode', value: 'Immutable' },
+]
+
+export default function App() {
+  async function pingAtlas() {
+    const response = await seq.api.get<{ ok?: boolean }>('/api/health')
+    alert(`Atlas responded: ${JSON.stringify(response)}`)
+  }
+
+  return (
+    <main className="min-h-screen bg-background p-10">
+      <p className="text-xs font-extrabold tracking-widest uppercase text-primary mb-2">
+        Artifact Studio
+      </p>
+      <h1 className="text-lg font-bold tracking-tight">Build on Atlas</h1>
+      <p className="text-muted-foreground leading-relaxed max-w-2xl mt-2">
+        This app uses Atlas&apos;s shared UI component library. Import any
+        component from <code className="text-sm font-mono">@sequenceholdings/atlas-ui</code>.
+      </p>
+
+      <div className="grid grid-cols-1 sm:grid-cols-3 gap-sm mt-7 max-w-3xl">
+        {CARDS.map((card) => (
+          <Card key={card.label}>
+            <CardHeader>
+              <CardTitle className="text-sm text-muted-foreground">
+                {card.label}
+              </CardTitle>
+            </CardHeader>
+            <CardContent>
+              <Badge variant="secondary">{card.value}</Badge>
+            </CardContent>
+          </Card>
+        ))}
+      </div>
+
+      <Button className="mt-6" onClick={pingAtlas}>
+        Test Atlas API bridge
+      </Button>
+    </main>
+  )
+}

package/dist/templates/react-vite/src/lib/api.ts

@@ -0,0 +1,13 @@
+import { seq } from '@sequenceholdings/artifact-studio'
+
+export async function unwrap<T>(p: Promise<unknown>): Promise<T> {
+  const json = await p
+  if (json && typeof json === 'object' && 'success' in json && 'data' in json) {
+    const env = json as { success: boolean; data: T; error?: string }
+    if (!env.success) throw new Error(env.error ?? 'API call failed')
+    return env.data
+  }
+  return json as T
+}
+
+export { seq }

package/dist/templates/react-vite/src/main.tsx

@@ -0,0 +1,18 @@
+import React from 'react'
+import { createRoot } from 'react-dom/client'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { PortalContainerProvider } from '@sequenceholdings/atlas-ui'
+import App from './App'
+import './styles.css'
+
+const queryClient = new QueryClient()
+
+createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <QueryClientProvider client={queryClient}>
+      <PortalContainerProvider>
+        <App />
+      </PortalContainerProvider>
+    </QueryClientProvider>
+  </React.StrictMode>,
+)

package/dist/templates/react-vite/src/styles.css

@@ -0,0 +1,3 @@
+@import "tailwindcss";
+@import "tw-animate-css";
+@import "@sequenceholdings/atlas-ui/tokens.css";

package/dist/templates/react-vite/vite.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+})

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@sequenceholdings/artifact-studio",
+  "version": "0.1.0",
+  "description": "CLI and SDK types for building Artifact Studio apps",
+  "type": "module",
+  "bin": {
+    "artifact-studio": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/sdk.d.ts",
+      "default": "./dist/sdk.js"
+    },
+    "./cli": {
+      "types": "./dist/cli.d.ts",
+      "default": "./dist/cli.js"
+    }
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "@tailwindcss/postcss": "^4.1.8",
+    "@tailwindcss/vite": "^4.1.8",
+    "js-yaml": "^4.1.1",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "tailwindcss": "^4.1.8",
+    "tw-animate-css": "^1.4.0",
+    "vite": "8.0.8",
+    "zod": "^4.1.13",
+    "@sequenceholdings/atlas-ui": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0",
+    "vitest": "^4.1.2"
+  },
+  "scripts": {
+    "build": "tsc && node scripts/copy-templates.mjs",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}

package/templates/react-vite/CLAUDE.md

@@ -0,0 +1,55 @@
+# Sequence Artifact Studio app
+
+This is a sandboxed iframe SPA that runs inside Atlas and talks to Atlas backend routes through a postMessage bridge exposed as `seq.api.*` from `@sequenceholdings/artifact-studio`. No direct network access, no API keys in the bundle — everything goes through the bridge, and every endpoint the artifact uses must be declared in `artifact.bundle.yml`.
+
+## Three rules that bite
+
+1. **Envelope unwrap.** Atlas wraps every CRM-style response in `{ success: true, data: T }`. The bridge passes that envelope through raw — it does **not** unwrap automatically. Route every read/write through `unwrap<T>()` in `src/lib/api.ts`:
+   ```ts
+   import { unwrap, seq } from './lib/api'
+   const customer = await unwrap<Customer>(seq.api.get(`/api/crm/customers/${id}`))
+   ```
+   For endpoints with extra envelope fields (pagination `meta`, warnings), drop to `seq.api.fetch` and read `res.body` directly.
+
+2. **FormData blocker.** `seq.api.fetch` `JSON.stringify`s any non-string `body` value, which silently turns `FormData` into `"{}"`. For uploads, base64-encode the bytes and POST as JSON, or patch the Atlas bridge first.
+
+3. **Capability matcher: exact path or `/*` prefix wildcard only.** `{id}` template forms do **not** match. List both the bare path and the prefix wildcard in `artifact.bundle.yml`:
+   ```yaml
+   - /api/crm/customers
+   - /api/crm/customers/*
+   ```
+
+## Prerequisite
+
+`artifact-studio init` requires the Sequence monorepo checked out locally. The CLI rewrites `"@sequenceholdings/atlas-ui": "workspace:*"` and the `@sequenceholdings/artifact-studio` entry in this `package.json` to local `link:` paths against the monorepo's `shared/services/atlas-ui` and `shared/services/artifact-studio`. Without the monorepo the rewrite no-ops, and `pnpm install` then fails on the unresolved `workspace:*` — those two packages aren't published to the public npm registry yet. Run init from inside the monorepo, e.g. `pnpm --dir atlas artifact-studio init <dir>`.
+
+## Package manager: pnpm
+
+This scaffold declares `"packageManager": "pnpm@10.28.2"` and the CLI writes both `@sequenceholdings/atlas-ui` and `@sequenceholdings/artifact-studio` as **`link:` deps** (not `file:`). `link:` is pnpm-specific: it tells pnpm to symlink the package without re-resolving its transitive `workspace:*` deps. That matters because the linked `@sequenceholdings/artifact-studio` package still carries `"@sequenceholdings/atlas-ui": "workspace:*"` in its own `package.json`; with `file:` pnpm would try to resolve that protocol against the standalone scaffold and fail with `ERR_PNPM_WORKSPACE_PKG_NOT_FOUND`. Always `pnpm install` — npm doesn't understand `link:`.
+
+## Key files
+
+| File | Role |
+|---|---|
+| `artifact.bundle.yml` | Capability manifest — every API path the artifact calls, exact + `/*` |
+| `src/main.tsx` | Providers: `QueryClientProvider` → `PortalContainerProvider` → `App` |
+| `src/App.tsx` | Entrypoint UI |
+| `src/lib/api.ts` | `unwrap<T>` envelope helper + re-export of `seq` |
+| `src/styles.css` | Tailwind v4 + `@sequenceholdings/atlas-ui/tokens.css` |
+| `vite.config.ts` | Vite + React + Tailwind v4 plugin |
+
+## Defaults
+
+- UI: prefer `@sequenceholdings/atlas-ui` primitives (`Button`, `Card`, `Input`, `Dialog`, `KpiTile`, `Switch`, …) over raw Tailwind. `Select`, `Checkbox`, and `DropdownMenu` are not exported — use native `<select>`, `Switch`, and `Popover` respectively.
+- Routing: `HashRouter`. Mount routes at `/`, not at the Atlas app prefix.
+- Data: React Query is wired in `src/main.tsx`. Use `useQuery` / `useMutation` against `unwrap(seq.api.*)`.
+- Icons: do **not** install `@tabler/icons-react` — it won't resolve from the artifact's local `node_modules`. Inline SVG components in `src/icons.tsx`.
+
+## Bridge methods
+
+Two primitives on `seq.api`:
+
+- `seq.api.fetch(path, options?)` returns `{ ok, status, body }` — does not throw on non-2xx. Use when you need the status (e.g. handle 409) or the raw envelope with extra fields like `meta`.
+- `seq.api.request(method, path, body?)` throws on non-2xx and returns parsed JSON. Sugar wrappers `seq.api.get / .post / .patch / .delete` are thin shells around `request`, so they also throw.
+
+Wrap reads/writes that should auto-throw through `unwrap()` in `src/lib/api.ts`. Drop to `seq.api.fetch` when you need pagination `meta` or status inspection.

package/templates/react-vite/artifact.bundle.yml

@@ -0,0 +1,30 @@
+bundle:
+  name: {{slug}}
+  schema_version: 1
+
+artifact:
+  project_id: {{slug}}
+  title: "{{title}}"
+  description: "A Git-backed Artifact Studio app"
+  type: react
+  entrypoint: src/App.tsx
+
+runtime:
+  sdk: sequence
+  react: 18
+
+capabilities:
+  data:
+    read: []
+    write: []
+  api:
+    read:
+      - /api/health
+    write: []
+  functions:
+    invoke: []
+
+targets:
+  staging:
+    url: https://staging.atlas.seqholdings.com
+    visibility: private

package/templates/react-vite/index.html

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

package/templates/react-vite/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "{{slug}}",
+  "private": true,
+  "type": "module",
+  "packageManager": "pnpm@10.28.2",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@sequenceholdings/artifact-studio": "workspace:*",
+    "@sequenceholdings/atlas-ui": "workspace:*",
+    "@tanstack/react-query": "^4.36.1",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4.2.2",
+    "@tailwindcss/vite": "^4.2.2",
+    "@vitejs/plugin-react": "^5.0.0",
+    "tailwindcss": "^4.2.2",
+    "tw-animate-css": "^1.4.0",
+    "typescript": "^5.6.0",
+    "vite": "8.0.8"
+  }
+}