{
  "generated_at": "2026-09-01T10:08:50.143Z",
  "canonical_origin": "https://miosa.ai",
  "worker_fallback_origin": "https://miosa.roberto-c49.workers.dev",
  "docs_home": "https://miosa.ai/docs",
  "agent_guide": "https://miosa.ai/docs/guides/agent-operating-guide",
  "llms": "https://miosa.ai/llms.txt",
  "llms_full": "https://miosa.ai/llms-full.txt",
  "openapi": "https://miosa.ai/openapi.yaml",
  "operating_contract": {
    "discovery": [
      "miosa capabilities --json",
      "miosa app inspect ./app --json",
      "miosa app plan ./app --goal deploy --json"
    ],
    "release": [
      "miosa app link ./app --app <deployment-id> --environment production --json",
      "miosa app pull ./app --json",
      "miosa app preview ./app --json",
      "miosa app verify <release-id> ./app --json",
      "miosa app promote <release-id> ./app --yes --json"
    ],
    "recovery": "miosa app recover <operation-id> ./app --resume --json",
    "rollback": "miosa app rollback <release-id> ./app --yes --json",
    "rules": [
      "Run `miosa capabilities --json`, `miosa app inspect`, and `miosa app plan` before reconstructing a workflow from old examples.",
      "Resolve one exact organization, workspace, application, and environment before mutating resources.",
      "Reuse the linked persistent sandbox unless it is proven terminal. Do not replace resources because an identifier or route was not resolved.",
      "Use `miosa app preview` to create and test an immutable candidate release. Preview never promotes production.",
      "Verify and promote one exact release ID. Never promote an inferred latest release.",
      "Call a release live only when the active release, running artifact digest, route contract, placement, data bindings, and required configuration agree.",
      "Recover interrupted operations with the recorded operation ID and idempotency key instead of starting duplicates.",
      "Use URLs returned by MIOSA. Do not construct preview, deployment, or custom-domain hostnames."
    ]
  },
  "pages": [
    {
      "slug": "",
      "path": "/docs",
      "url": "https://miosa.ai/docs",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs",
      "title": "MIOSA Documentation",
      "description": "Build, preview, deploy, prove, and operate AI-generated applications on MIOSA sandboxes, computers, App Engine, and white-label domains.",
      "source": "src/routes/docs/+page.md",
      "headings": [
        {
          "title": "Explore the platform",
          "anchor": "explore-the-platform"
        },
        {
          "title": "Core infrastructure",
          "anchor": "core-infrastructure"
        },
        {
          "title": "What you can build",
          "anchor": "what-you-can-build"
        },
        {
          "title": "Platform guides",
          "anchor": "platform-guides"
        },
        {
          "title": "Developer surfaces",
          "anchor": "developer-surfaces"
        },
        {
          "title": "For LLMs",
          "anchor": "for-llms"
        },
        {
          "title": "Current production contract",
          "anchor": "current-production-contract"
        }
      ],
      "content_excerpt": "## Explore the platform\n\n  \n    Run many workspace apps as containers on one always-on App Engine host, with MIOSA-owned routing, domains, and proof.\n  \n\n  \n    Dispatch Claude Code, Codex, or command runners to sandboxes and computers, then stream events and collect artifacts.\n  \n\n  \n    Follow the authoritative discovery, preview, verification, promotion, recovery, and rollback contract for automated workers.\n  \n\n  \n    Use REST, CLI, TypeScript, Python, Go, Java, Elixir, MCP, and ADK surfaces"
    },
    {
      "slug": "adk",
      "path": "/docs/adk",
      "url": "https://miosa.ai/docs/adk",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/adk",
      "title": "Agent Development Kit (ADK)",
      "description": "Build LLM agents that use MIOSA sandboxes, desktops, and deploys with the tool-call loop already wired. TypeScript ADK first; Python next.",
      "source": "src/routes/docs/adk/+page.md",
      "headings": [
        {
          "title": "30-second example",
          "anchor": "30-second-example"
        },
        {
          "title": "ADK vs SDK",
          "anchor": "adk-vs-sdk"
        },
        {
          "title": "Built-in MIOSA tools",
          "anchor": "built-in-miosa-tools"
        },
        {
          "title": "Custom tools",
          "anchor": "custom-tools"
        },
        {
          "title": "Streaming step events",
          "anchor": "streaming-step-events"
        },
        {
          "title": "Providers",
          "anchor": "providers"
        },
        {
          "title": "Termination",
          "anchor": "termination"
        },
        {
          "title": "Quick comparison",
          "anchor": "quick-comparison"
        },
        {
          "title": "What's coming next",
          "anchor": "whats-coming-next"
        }
      ],
      "content_excerpt": "# Agent Development Kit (ADK)\n\nThe MIOSA ADK lets you build production-ready LLM agents that natively use\nMIOSA primitives  -  sandboxes, full desktop environments, and one-click\ndeploys  -  with the tool-call loop already wired.\n\nIf `@miosa/sdk` is \"call MIOSA APIs from code\", `@miosa/adk` is **\"build an\nAGENT that uses MIOSA\"**.\n\n```bash\nnpm install @miosa/adk @anthropic-ai/sdk\n```\n\n---\n\n## 30-second example\n\n```typescript\n\nconst agent = new Agent({\n  provider: anthropicProvider({\n    apiKey: "
    },
    {
      "slug": "api",
      "path": "/docs/api",
      "url": "https://miosa.ai/docs/api",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api",
      "title": "Interactive API Reference  -  MIOSA Docs",
      "description": "Browse and try the allowlisted MIOSA Sandbox V1 API interactively. Use the written endpoint guides for the wider platform API.",
      "source": "src/routes/docs/api/+page.svelte",
      "headings": [],
      "content_excerpt": "This interactive reference covers the allowlisted Sandbox V1 OpenAPI surface. Use the written API reference for deployments, databases, computers, and the wider platform contract. {#if !mounted} {/if}"
    },
    {
      "slug": "api-reference",
      "path": "/docs/api-reference",
      "url": "https://miosa.ai/docs/api-reference",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference",
      "title": "API Reference",
      "description": "REST API reference for the MIOSA platform - base URL, auth, request/response envelopes, and endpoint guides.",
      "source": "src/routes/docs/api-reference/+page.md",
      "headings": [
        {
          "title": "Base URL",
          "anchor": "base-url"
        },
        {
          "title": "Authentication",
          "anchor": "authentication"
        },
        {
          "title": "Request format",
          "anchor": "request-format"
        },
        {
          "title": "Response envelope",
          "anchor": "response-envelope"
        },
        {
          "title": "Error envelope",
          "anchor": "error-envelope"
        },
        {
          "title": "HTTP status codes",
          "anchor": "http-status-codes"
        },
        {
          "title": "Rate limits",
          "anchor": "rate-limits"
        },
        {
          "title": "IDs and timestamps",
          "anchor": "ids-and-timestamps"
        },
        {
          "title": "Ownership fields",
          "anchor": "ownership-fields"
        },
        {
          "title": "Compute",
          "anchor": "compute"
        },
        {
          "title": "Deploy",
          "anchor": "deploy"
        },
        {
          "title": "Computers",
          "anchor": "computers"
        },
        {
          "title": "Platform",
          "anchor": "platform"
        }
      ],
      "content_excerpt": "Want to browse and try endpoints without writing code?\n  The <a href=\"/docs/api\">Interactive Sandbox API Reference</a> renders the\n  allowlisted public Sandbox V1 OpenAPI contract with an in-browser request runner.\n  Use the endpoint guides below for the wider platform API.\n\nEvery MIOSA API endpoint is REST over HTTPS, returns JSON, and follows a consistent envelope format. The SDKs wrap these endpoints  -  you can use them directly when you need low-level control or want to integrate from a lan"
    },
    {
      "slug": "api-reference/agent-run-groups",
      "path": "/docs/api-reference/agent-run-groups",
      "url": "https://miosa.ai/docs/api-reference/agent-run-groups",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/agent-run-groups",
      "title": "Agent Run Groups",
      "description": "Create durable multi-agent orchestration groups, dispatch run manifests, inspect counts, and cancel grouped work.",
      "source": "src/routes/docs/api-reference/agent-run-groups/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Create",
          "anchor": "create"
        },
        {
          "title": "Dispatch",
          "anchor": "dispatch"
        },
        {
          "title": "Response",
          "anchor": "response"
        },
        {
          "title": "Events",
          "anchor": "events"
        },
        {
          "title": "SDK",
          "anchor": "sdk"
        },
        {
          "title": "CLI",
          "anchor": "cli"
        },
        {
          "title": "Next",
          "anchor": "next"
        }
      ],
      "content_excerpt": "# Agent Run Groups\n\nAgent Run Groups are the durable control-plane object for multi-agent fanout.\nUse a group when one user request creates many related Agent Runs across\nsandboxes, computers, or custom runtimes.\n\nBase path: `/api/v1/agent-run-groups`\n\nUse synchronous dispatch for small fanout where you want child run creation in\nthe response. Use `async: true` for queued fanout: MIOSA stores each manifest\nentry, enforces the group's concurrency limit while workers claim entries, and\nreturns imm"
    },
    {
      "slug": "api-reference/agent-runs",
      "path": "/docs/api-reference/agent-runs",
      "url": "https://miosa.ai/docs/api-reference/agent-runs",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/agent-runs",
      "title": "Agent Runs",
      "description": "Dispatch prompts into MIOSA devices with a stable run response shape for agent work.",
      "source": "src/routes/docs/api-reference/agent-runs/+page.md",
      "headings": [
        {
          "title": "Flow",
          "anchor": "flow"
        },
        {
          "title": "Create a run",
          "anchor": "create-a-run"
        },
        {
          "title": "Request fields",
          "anchor": "request-fields"
        },
        {
          "title": "Response",
          "anchor": "response"
        },
        {
          "title": "Status values",
          "anchor": "status-values"
        },
        {
          "title": "Artifacts",
          "anchor": "artifacts"
        },
        {
          "title": "Events",
          "anchor": "events"
        },
        {
          "title": "Cancellation",
          "anchor": "cancellation"
        },
        {
          "title": "Run history",
          "anchor": "run-history"
        },
        {
          "title": "SDK examples",
          "anchor": "sdk-examples"
        },
        {
          "title": "CLI",
          "anchor": "cli"
        },
        {
          "title": "Product guidance",
          "anchor": "product-guidance"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Agent Runs\n\nAgent Runs are the prompt-dispatch interface for MIOSA sandboxes and computers.\nUse them when your product needs to send a natural-language task into a device, run it\nthrough OSA, Codex, Claude Code, Pi, Hermes, or a custom runtime, and receive a\nstable run response your UI can render.\n\nThis is the API behind:\n\n- `miosa agent run --sandbox ...`\n- `miosa agent run --computer ...`\n- `miosa sandbox prompt`\n- `client.agentRuns.run(...)` in the TypeScript SDK\n- `client.agent_runs.run(.."
    },
    {
      "slug": "api-reference/agent-runtime-profiles",
      "path": "/docs/api-reference/agent-runtime-profiles",
      "url": "https://miosa.ai/docs/api-reference/agent-runtime-profiles",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/agent-runtime-profiles",
      "title": "Agent Runtime Profiles",
      "description": "Configure reusable agent runtime defaults for sandboxes, computers, and custom agent sessions.",
      "source": "src/routes/docs/api-reference/agent-runtime-profiles/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Create",
          "anchor": "create"
        },
        {
          "title": "Fields",
          "anchor": "fields"
        },
        {
          "title": "Resolution",
          "anchor": "resolution"
        },
        {
          "title": "CLI",
          "anchor": "cli"
        },
        {
          "title": "Next",
          "anchor": "next"
        }
      ],
      "content_excerpt": "# Agent Runtime Profiles\n\nAgent Runtime Profiles define how MIOSA should prepare an agent runtime for a\ntenant, workspace, or project. Use profiles to standardize OSA, Codex, Claude\nCode, Pi, Hermes, or custom runtimes across sandboxes and computers without\npassing the same model, tools, connectors, policy, and environment on every run.\n\nBase path: `/api/v1/agent-runtime-profiles`\n\nProfiles configure runtime shape. Agent Runs still provide the prompt, target,\ntimeout, and task-specific metadata."
    },
    {
      "slug": "api-reference/audit-log",
      "path": "/docs/api-reference/audit-log",
      "url": "https://miosa.ai/docs/api-reference/audit-log",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/audit-log",
      "title": "Audit Log API",
      "description": "Retrieve a cursor-paginated audit log of all actions taken within your tenant.",
      "source": "src/routes/docs/api-reference/audit-log/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "List Audit Events",
          "anchor": "list-audit-events"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Common Event Types",
          "anchor": "common-event-types"
        },
        {
          "title": "Pagination",
          "anchor": "pagination"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        }
      ],
      "content_excerpt": "The audit log records all significant actions performed within your tenant  -  resource creation and deletion, API key usage, settings changes, and more. Results are cursor-paginated and ordered newest-first.\n\nBase path: `/api/v1/audit-log`\n\nAudit events are immutable. There is no write API. The log is append-only and retained for 90 days on Pro plans, 365 days on Enterprise.\n\n---\n\n## Endpoints\n\n| Method | Path | Description |\n|--------|------|-------------|\n| `GET` | `/api/v1/audit-log` | Fetch"
    },
    {
      "slug": "api-reference/cloud",
      "path": "/docs/api-reference/cloud",
      "url": "https://miosa.ai/docs/api-reference/cloud",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/cloud",
      "title": "Cloud and BYOC API",
      "description": "Organization-scoped AWS and GCP accounts, regions, pools, nodes, preflight, and host provisioning.",
      "source": "src/routes/docs/api-reference/cloud/+page.md",
      "headings": [
        {
          "title": "Accounts",
          "anchor": "accounts"
        },
        {
          "title": "Regions",
          "anchor": "regions"
        },
        {
          "title": "Pools",
          "anchor": "pools"
        },
        {
          "title": "Nodes",
          "anchor": "nodes"
        },
        {
          "title": "Preflight",
          "anchor": "preflight"
        },
        {
          "title": "SDK",
          "anchor": "sdk"
        }
      ],
      "content_excerpt": "Base path: `/api/v1/cloud`\n\nAll resources belong to the active organization, which is returned as both `organization_id` and the compatibility field `tenant_id`.\nCloud reads require `cloud:read` and mutations require `cloud:write`.\nOrganization members can read inventory.\nOrganization owners and admins can mutate it.\nWorkspace-scoped credentials cannot mutate organization cloud capacity.\n\nAWS and GCP BYOC are gated private previews.\nProvider connection and preflight do not make workload placemen"
    },
    {
      "slug": "api-reference/computers",
      "path": "/docs/api-reference/computers",
      "url": "https://miosa.ai/docs/api-reference/computers",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/computers",
      "title": "Computers API",
      "description": "API reference for creating, managing, and controlling MIOSA computers  -  full lifecycle, desktop control, files, metrics, and env vars.",
      "source": "src/routes/docs/api-reference/computers/+page.md",
      "headings": [
        {
          "title": "Create a Computer",
          "anchor": "create-a-computer"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "List Computers",
          "anchor": "list-computers"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Get a Computer",
          "anchor": "get-a-computer"
        },
        {
          "title": "Path Parameters",
          "anchor": "path-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Update a Computer",
          "anchor": "update-a-computer"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Delete a Computer",
          "anchor": "delete-a-computer"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Start a Computer",
          "anchor": "start-a-computer"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Stop a Computer",
          "anchor": "stop-a-computer"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Restart a Computer",
          "anchor": "restart-a-computer"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Get Auto-Stop Configuration",
          "anchor": "get-auto-stop-configuration"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Update Auto-Stop Configuration",
          "anchor": "update-auto-stop-configuration"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Get Desktop Stream Credentials",
          "anchor": "get-desktop-stream-credentials"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Get Stream Token",
          "anchor": "get-stream-token"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Get Computer URLs",
          "anchor": "get-computer-urls"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "List Installed Apps",
          "anchor": "list-installed-apps"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Clone a Computer",
          "anchor": "clone-a-computer"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Resize a Computer",
          "anchor": "resize-a-computer"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Move a Computer",
          "anchor": "move-a-computer"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Get Metrics",
          "anchor": "get-metrics"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Env Vars",
          "anchor": "env-vars"
        },
        {
          "title": "List",
          "anchor": "list"
        },
        {
          "title": "Create",
          "anchor": "create"
        },
        {
          "title": "Update",
          "anchor": "update"
        },
        {
          "title": "Delete",
          "anchor": "delete"
        },
        {
          "title": "Port Exposure",
          "anchor": "port-exposure"
        },
        {
          "title": "List Ports",
          "anchor": "list-ports"
        },
        {
          "title": "Expose a Port",
          "anchor": "expose-a-port"
        },
        {
          "title": "Update Port Visibility",
          "anchor": "update-port-visibility"
        },
        {
          "title": "Remove Port",
          "anchor": "remove-port"
        },
        {
          "title": "Common Errors",
          "anchor": "common-errors"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Computers are persistent desktop VMs with a Linux desktop, streamed desktop access, and APIs for exec, files, apps, metrics, and desktop control. Base path: `/api/v1/computers`.\n\nVerbs supported: **GET** (list/get/config), **POST** (create/start/stop/restart/clone/resize), **PATCH** (update), **PUT** (update), **DELETE** (delete).\n\nAll mutation endpoints (`POST`, `PATCH`, `PUT`, `DELETE`) accept an `Idempotency-Key` header. Use a UUID v4. Repeating the same key within 24 hours returns the origin"
    },
    {
      "slug": "api-reference/credits",
      "path": "/docs/api-reference/credits",
      "url": "https://miosa.ai/docs/api-reference/credits",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/credits",
      "title": "Credits API",
      "description": "API reference for checking credit balance, transaction history, and usage data.",
      "source": "src/routes/docs/api-reference/credits/+page.md",
      "headings": [
        {
          "title": "Get Balance",
          "anchor": "get-balance"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Response Fields",
          "anchor": "response-fields"
        },
        {
          "title": "Get Transactions",
          "anchor": "get-transactions"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Transaction Fields",
          "anchor": "transaction-fields"
        },
        {
          "title": "Get Usage Summary",
          "anchor": "get-usage-summary"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Usage Entry Fields",
          "anchor": "usage-entry-fields"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Credit Pricing",
          "anchor": "credit-pricing"
        },
        {
          "title": "Compute Credits",
          "anchor": "compute-credits"
        },
        {
          "title": "AI Credits (per 1M tokens)",
          "anchor": "ai-credits-per-1m-tokens"
        },
        {
          "title": "Plans",
          "anchor": "plans"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "MIOSA uses a credit-based billing system. Credits are consumed for compute time and AI API calls.\n\nBase path: `/api/v1/credits`\n\n---\n\n## Get Balance\n\n**`GET /api/v1/credits/balance`**\n\nReturns the current credit balance for your tenant.\n\n### Response  -  `200 OK`\n```json\n{\n  \"tenant_id\": \"550e8400-e29b-41d4-a716-446655440000\",\n  \"balance_credits\": 850,\n  \"lifetime_earned\": 1000,\n  \"lifetime_spent\": 150,\n  \"credit_expiry_at\": \"2026-10-08T00:00:00Z\",\n  \"updated_at\": \"2026-04-11T15:00:00Z\"\n}\n```\n\n#"
    },
    {
      "slug": "api-reference/custom-domains",
      "path": "/docs/api-reference/custom-domains",
      "url": "https://miosa.ai/docs/api-reference/custom-domains",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/custom-domains",
      "title": "Custom Domains API",
      "description": "API reference for mapping tenant-owned FQDNs to MIOSA previews with automatic TLS.",
      "source": "src/routes/docs/api-reference/custom-domains/+page.md",
      "headings": [
        {
          "title": "Quick Start",
          "anchor": "quick-start"
        },
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Computer custom domains",
          "anchor": "computer-custom-domains"
        },
        {
          "title": "Deployment custom domains",
          "anchor": "deployment-custom-domains"
        },
        {
          "title": "Flat custom domains",
          "anchor": "flat-custom-domains"
        },
        {
          "title": "Tenant preview domains",
          "anchor": "tenant-preview-domains"
        },
        {
          "title": "Workspace and project preview domains",
          "anchor": "workspace-and-project-preview-domains"
        },
        {
          "title": "White-label Managed Links",
          "anchor": "white-label-managed-links"
        },
        {
          "title": "Register a Domain",
          "anchor": "register-a-domain"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Status Values",
          "anchor": "status-values"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Register a deployment domain",
          "anchor": "register-a-deployment-domain"
        },
        {
          "title": "List Domains",
          "anchor": "list-domains"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Verify a Domain",
          "anchor": "verify-a-domain"
        },
        {
          "title": "Path Parameters",
          "anchor": "path-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Remove a Domain",
          "anchor": "remove-a-domain"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "DNS Setup Reference",
          "anchor": "dns-setup-reference"
        },
        {
          "title": "Common Recipes",
          "anchor": "common-recipes"
        },
        {
          "title": "Automate full domain onboarding",
          "anchor": "automate-full-domain-onboarding"
        },
        {
          "title": "List all pending domains (potential stuck ACME issuances)",
          "anchor": "list-all-pending-domains-potential-stuck-acme-issuances"
        }
      ],
      "content_excerpt": "Custom domains let you expose MIOSA previews, computers, and deployments under tenant-owned FQDNs. There are four related surfaces:\n\n- **Computer custom domains** map one fully qualified domain, such as `app.yourdomain.com`, to one Computer service.\n- **Deployment custom domains** map one fully qualified domain, such as `program.drsmithclinic.com`, to one Deployment.\n- **Tenant preview domains** white-label generated preview links for the whole organization. After configuration, sandbox `/expose"
    },
    {
      "slug": "api-reference/databases",
      "path": "/docs/api-reference/databases",
      "url": "https://miosa.ai/docs/api-reference/databases",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/databases",
      "title": "Databases API",
      "description": "Provision and operate managed databases, backups, restores, branches, replicas, credentials, and placement.",
      "source": "src/routes/docs/api-reference/databases/+page.md",
      "headings": [
        {
          "title": "Core lifecycle",
          "anchor": "core-lifecycle"
        },
        {
          "title": "Data topology and recovery",
          "anchor": "data-topology-and-recovery"
        },
        {
          "title": "Create",
          "anchor": "create"
        },
        {
          "title": "Credentials",
          "anchor": "credentials"
        },
        {
          "title": "Backup and restore",
          "anchor": "backup-and-restore"
        },
        {
          "title": "Permissions",
          "anchor": "permissions"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Managed databases have a lifecycle independent from sandboxes and deployment runtime instances.\nDeleting or replacing compute does not implicitly delete an attached database.\n\nBase path: `/api/v1/databases`\n\n## Core lifecycle\n\n| Method | Path | Purpose |\n|---|---|---|\n| `GET` | `/databases` | List databases visible to the current tenant and workspace scope |\n| `POST` | `/databases` | Create a managed database |\n| `GET` | `/databases/{id}` | Inspect one database |\n| `DELETE` | `/databases/{id}` |"
    },
    {
      "slug": "api-reference/deployments",
      "path": "/docs/api-reference/deployments",
      "url": "https://miosa.ai/docs/api-reference/deployments",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/deployments",
      "title": "API Reference / Deployments",
      "description": "REST API for the Deployment resource  -  create, list, get, update, delete, publish, rollback.",
      "source": "src/routes/docs/api-reference/deployments/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Create",
          "anchor": "create"
        },
        {
          "title": "Publish",
          "anchor": "publish"
        },
        {
          "title": "List",
          "anchor": "list"
        },
        {
          "title": "Get",
          "anchor": "get"
        },
        {
          "title": "Update",
          "anchor": "update"
        },
        {
          "title": "Rollback",
          "anchor": "rollback"
        },
        {
          "title": "Delete",
          "anchor": "delete"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "A **Deployment** is the stable production object for a published app/site/API. See [Deploy / Overview](/docs/deploy/overview/) for the conceptual model.\n\nUse `POST /api/v1/sandboxes/:id/publish` or `miosa sandbox publish` to turn a tested sandbox into an immutable release.\nPass an existing deployment ID when updating so its identity and URL remain stable.\n\n## Endpoints\n```http\nPOST   /api/v1/projects/:project_id/deployments\nGET    /api/v1/deployments\nGET    /api/v1/deployments/:id\nPATCH  /api/v1"
    },
    {
      "slug": "api-reference/desktop",
      "path": "/docs/api-reference/desktop",
      "url": "https://miosa.ai/docs/api-reference/desktop",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/desktop",
      "title": "Desktop API",
      "description": "API reference for all desktop control endpoints  -  screenshot, mouse, keyboard, clipboard, windows, accessibility tree.",
      "source": "src/routes/docs/api-reference/desktop/+page.md",
      "headings": [
        {
          "title": "Screenshot",
          "anchor": "screenshot"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Screenshot Region",
          "anchor": "screenshot-region"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Click",
          "anchor": "click"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Double-Click",
          "anchor": "double-click"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Type Text",
          "anchor": "type-text"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Key Press",
          "anchor": "key-press"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Common Keys",
          "anchor": "common-keys"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Scroll",
          "anchor": "scroll"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Drag",
          "anchor": "drag"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Wait",
          "anchor": "wait"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "List Windows",
          "anchor": "list-windows"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Focus Window",
          "anchor": "focus-window"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Launch Application",
          "anchor": "launch-application"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Cursor Position",
          "anchor": "cursor-position"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Hotkey",
          "anchor": "hotkey"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Key Down / Key Up",
          "anchor": "key-down-key-up"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Mouse Down / Mouse Up",
          "anchor": "mouse-down-mouse-up"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Move Mouse",
          "anchor": "move-mouse"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Clipboard",
          "anchor": "clipboard"
        },
        {
          "title": "Get Clipboard",
          "anchor": "get-clipboard"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Set Clipboard",
          "anchor": "set-clipboard"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Screen Size",
          "anchor": "screen-size"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Environment",
          "anchor": "environment"
        },
        {
          "title": "Set Wallpaper",
          "anchor": "set-wallpaper"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Accessibility Tree",
          "anchor": "accessibility-tree"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Window Management",
          "anchor": "window-management"
        },
        {
          "title": "List Windows",
          "anchor": "list-windows"
        },
        {
          "title": "Window Size",
          "anchor": "window-size"
        },
        {
          "title": "Window Position",
          "anchor": "window-position"
        },
        {
          "title": "Resize Window",
          "anchor": "resize-window"
        },
        {
          "title": "Move Window",
          "anchor": "move-window"
        },
        {
          "title": "Maximize Window",
          "anchor": "maximize-window"
        },
        {
          "title": "Minimize Window",
          "anchor": "minimize-window"
        },
        {
          "title": "Close Window",
          "anchor": "close-window"
        },
        {
          "title": "Common Errors",
          "anchor": "common-errors"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Desktop control endpoints proxy commands to the computer command service inside the computer VM via the MIOSA control plane. All coordinates are in screen pixels (0,0 = top-left).\n\nBase path: `/api/v1/computers/{id}/desktop`\n\nAll desktop endpoints require the computer to be in `\"running\"` status. Returns `409 COMPUTER_NOT_RUNNING` if the computer is stopped or provisioning.\n\nRate limits vary by key, tenant policy, and endpoint family. Honor `X-RateLimit-*` and `Retry-After` response headers. Ind"
    },
    {
      "slug": "api-reference/docker-deploy",
      "path": "/docs/api-reference/docker-deploy",
      "url": "https://miosa.ai/docs/api-reference/docker-deploy",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/docker-deploy",
      "title": "API Reference / App Engine",
      "description": "REST API for App Engine templates, workspace hosts, and sandbox-to-container publishing.",
      "source": "src/routes/docs/api-reference/docker-deploy/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "List templates",
          "anchor": "list-templates"
        },
        {
          "title": "Get template",
          "anchor": "get-template"
        },
        {
          "title": "List workspace hosts",
          "anchor": "list-workspace-hosts"
        },
        {
          "title": "Ensure workspace host",
          "anchor": "ensure-workspace-host"
        },
        {
          "title": "Get host",
          "anchor": "get-host"
        },
        {
          "title": "Publish from sandbox",
          "anchor": "publish-from-sandbox"
        },
        {
          "title": "Publish existing deployment",
          "anchor": "publish-existing-deployment"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "App Engine is the dedicated workspace host for customers who need many containerized apps on one always-on MIOSA-managed runtime.\n\nUse the regular Deployments API for the deployment object.\nUse the App Engine API to choose templates and provision the workspace host.\n\nApp Engine apps still return normal MIOSA deployment URLs and custom-domain records.\nThe workspace host runs the app containers while MIOSA owns DNS, TLS, routing, health checks, and deployment records.\n\n## Endpoints\n\n```http\nGET  /"
    },
    {
      "slug": "api-reference/egress",
      "path": "/docs/api-reference/egress",
      "url": "https://miosa.ai/docs/api-reference/egress",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/egress",
      "title": "Egress (Security) API",
      "description": "API reference for the MIOSA Egress credential vault, network allowlist, OAuth Connect, and audit log.",
      "source": "src/routes/docs/api-reference/egress/+page.md",
      "headings": [
        {
          "title": "Secrets",
          "anchor": "secrets"
        },
        {
          "title": "Create a secret",
          "anchor": "create-a-secret"
        },
        {
          "title": "List secrets",
          "anchor": "list-secrets"
        },
        {
          "title": "Get a secret",
          "anchor": "get-a-secret"
        },
        {
          "title": "Rotate",
          "anchor": "rotate"
        },
        {
          "title": "Delete",
          "anchor": "delete"
        },
        {
          "title": "Bindings",
          "anchor": "bindings"
        },
        {
          "title": "Create a binding",
          "anchor": "create-a-binding"
        },
        {
          "title": "List + delete",
          "anchor": "list-delete"
        },
        {
          "title": "OAuth Connect",
          "anchor": "oauth-connect"
        },
        {
          "title": "List provider catalog",
          "anchor": "list-provider-catalog"
        },
        {
          "title": "Start an OAuth flow",
          "anchor": "start-an-oauth-flow"
        },
        {
          "title": "Status",
          "anchor": "status"
        },
        {
          "title": "Admin: tenant-override providers (white-label)",
          "anchor": "admin-tenant-override-providers-white-label"
        },
        {
          "title": "Network policies + allowlist",
          "anchor": "network-policies-allowlist"
        },
        {
          "title": "Policies",
          "anchor": "policies"
        },
        {
          "title": "Allowlist rules",
          "anchor": "allowlist-rules"
        },
        {
          "title": "Audit log",
          "anchor": "audit-log"
        },
        {
          "title": "Query",
          "anchor": "query"
        },
        {
          "title": "Get a single event",
          "anchor": "get-a-single-event"
        },
        {
          "title": "Allowlist suggestions",
          "anchor": "allowlist-suggestions"
        },
        {
          "title": "Live tail (WebSocket)",
          "anchor": "live-tail-websocket"
        },
        {
          "title": "Rate limits + retention",
          "anchor": "rate-limits-retention"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "SDK shortcut",
          "anchor": "sdk-shortcut"
        }
      ],
      "content_excerpt": "The Egress API powers the **Security** tab on every Computer and Sandbox: encrypted credential vault, OAuth Connect, network allowlist with audit-only / enforce modes, and a live-tail audit log.\n\nBase path: `/api/v1/egress`\n\nAll endpoints require `Authorization: Bearer &lt;msk_*&gt;`. See [Authentication](/docs/authentication). For higher-level access, use the [SDKs](/docs/sdks/egress).\n\nFor the architecture overview, walkthroughs, and white-label patterns, see the [Security guides](/docs/securi"
    },
    {
      "slug": "api-reference/errors",
      "path": "/docs/api-reference/errors",
      "url": "https://miosa.ai/docs/api-reference/errors",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/errors",
      "title": "Error Codes",
      "description": "Every error code the MIOSA API returns, what it means, and how to handle it.",
      "source": "src/routes/docs/api-reference/errors/+page.md",
      "headings": [
        {
          "title": "Authentication errors",
          "anchor": "authentication-errors"
        },
        {
          "title": "General resource errors",
          "anchor": "general-resource-errors"
        },
        {
          "title": "Sandbox errors",
          "anchor": "sandbox-errors"
        },
        {
          "title": "Sandbox template build errors",
          "anchor": "sandbox-template-build-errors"
        },
        {
          "title": "Computer errors",
          "anchor": "computer-errors"
        },
        {
          "title": "Deployment errors",
          "anchor": "deployment-errors"
        },
        {
          "title": "Snapshot errors",
          "anchor": "snapshot-errors"
        },
        {
          "title": "Custom domain errors",
          "anchor": "custom-domain-errors"
        },
        {
          "title": "Workspace errors",
          "anchor": "workspace-errors"
        },
        {
          "title": "Rate-limit and quota errors",
          "anchor": "rate-limit-and-quota-errors"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Every MIOSA API error follows a single envelope shape. The HTTP status indicates the broad class; the `code` field is the machine-readable reason.\n\n```json\n{\n  \"error\": {\n    \"code\": \"NOT_FOUND\",\n    \"message\": \"sandbox not found\",\n    \"request_id\": \"req_01jv...\"\n  }\n}\n```\n\nInclude `request_id` whenever you contact support. It correlates the request across all internal services.\n\n---\n\n## Authentication errors\n\nReturned by the `ApiKeyAuth` plug before the request reaches any controller.\n\n| Code |"
    },
    {
      "slug": "api-reference/events",
      "path": "/docs/api-reference/events",
      "url": "https://miosa.ai/docs/api-reference/events",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/events",
      "title": "Events (SSE)",
      "description": "Server-Sent Event streams for real-time updates from sandboxes, computers, deployments, and builds.",
      "source": "src/routes/docs/api-reference/events/+page.md",
      "headings": [
        {
          "title": "Authentication pattern",
          "anchor": "authentication-pattern"
        },
        {
          "title": "Live SSE streams",
          "anchor": "live-sse-streams"
        },
        {
          "title": "Event envelope",
          "anchor": "event-envelope"
        },
        {
          "title": "Sandbox event types",
          "anchor": "sandbox-event-types"
        },
        {
          "title": "Deployment event types",
          "anchor": "deployment-event-types"
        },
        {
          "title": "Computer event types",
          "anchor": "computer-event-types"
        },
        {
          "title": "Reconnect and replay",
          "anchor": "reconnect-and-replay"
        },
        {
          "title": "Error handling",
          "anchor": "error-handling"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "MIOSA exposes SSE streams for resources that produce timed events: sandboxes, computer sessions, deployment builds, sandbox-template builds, and computer logs. All streams follow the same authentication and envelope pattern.\n\n---\n\n## Authentication pattern\n\nThe browser `EventSource` API cannot send an `Authorization` header. Use the two-step ticket flow for all SSE connections:\nDiagram:\nsequenceDiagram\n  participant Client\n  participant MIOSA API\n  Client->>MIOSA API: POST /api/v1/auth/sse-ticke"
    },
    {
      "slug": "api-reference/exec",
      "path": "/docs/api-reference/exec",
      "url": "https://miosa.ai/docs/api-reference/exec",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/exec",
      "title": "Exec API",
      "description": "API reference for executing bash commands and Python code on MIOSA computers.",
      "source": "src/routes/docs/api-reference/exec/+page.md",
      "headings": [
        {
          "title": "Execute Bash Command",
          "anchor": "execute-bash-command"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        },
        {
          "title": "Execute Python Code",
          "anchor": "execute-python-code"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "How It Works",
          "anchor": "how-it-works"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        },
        {
          "title": "Terminal",
          "anchor": "terminal"
        },
        {
          "title": "Create Terminal Session",
          "anchor": "create-terminal-session"
        },
        {
          "title": "Resize Terminal",
          "anchor": "resize-terminal"
        },
        {
          "title": "Timeout Behavior",
          "anchor": "timeout-behavior"
        },
        {
          "title": "Pre-installed Software",
          "anchor": "pre-installed-software"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Run commands and scripts directly on a computer without desktop interaction. Both endpoints block until the command exits and return combined stdout+stderr.\n\nBase path: `/api/v1/computers/{id}/exec`\n\nThe computer must be in `\"running\"` status. Commands run as the default user inside the VM. Maximum timeout is 300 s.\n\nRate limits vary by key, tenant policy, and endpoint family. Honor `X-RateLimit-*` and `Retry-After` response headers. For long-running output, prefer the streaming exec endpoint wh"
    },
    {
      "slug": "api-reference/files",
      "path": "/docs/api-reference/files",
      "url": "https://miosa.ai/docs/api-reference/files",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/files",
      "title": "Files API",
      "description": "API reference for file upload, download, list, export, and delete operations.",
      "source": "src/routes/docs/api-reference/files/+page.md",
      "headings": [
        {
          "title": "Upload a File",
          "anchor": "upload-a-file"
        },
        {
          "title": "Request",
          "anchor": "request"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "List Directory",
          "anchor": "list-directory"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "File Entry Fields",
          "anchor": "file-entry-fields"
        },
        {
          "title": "Download a File",
          "anchor": "download-a-file"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Export a File",
          "anchor": "export-a-file"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Delete a File",
          "anchor": "delete-a-file"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Path Security",
          "anchor": "path-security"
        }
      ],
      "content_excerpt": "Manage files on a running computer. All paths are restricted to `/workspace`, `/home`, `/root`, `/tmp`, `/opt`, and `/srv`.\n\nBase path: `/api/v1/computers/{id}/files`\n\nThe computer must be in `\"running\"` status. All operations go through the computer command service.\n\n---\n\n## Upload a File\n\n**`POST /api/v1/computers/{id}/files/upload`**\n\nUploads a file to the computer via multipart form data.\n\n### Request\n\nContent-Type: `multipart/form-data`\n\n| Field | Type | Required | Description |\n|-------|--"
    },
    {
      "slug": "api-reference/filesystem",
      "path": "/docs/api-reference/filesystem",
      "url": "https://miosa.ai/docs/api-reference/filesystem",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/filesystem",
      "title": "Filesystem API",
      "description": "Complete API reference for file and directory operations on MIOSA computers  -  upload, download, stat, mkdir, rename, copy, chmod, and readdir.",
      "source": "src/routes/docs/api-reference/filesystem/+page.md",
      "headings": [
        {
          "title": "Quick Start",
          "anchor": "quick-start"
        },
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Upload a File",
          "anchor": "upload-a-file"
        },
        {
          "title": "Request  -  multipart/form-data",
          "anchor": "request-multipartform-data"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Write a File",
          "anchor": "write-a-file"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "List Directory (readdir)",
          "anchor": "list-directory-readdir"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Download a File",
          "anchor": "download-a-file"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Export a File",
          "anchor": "export-a-file"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Delete a File",
          "anchor": "delete-a-file"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Stat a File or Directory",
          "anchor": "stat-a-file-or-directory"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Create a Directory",
          "anchor": "create-a-directory"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Rename or Move",
          "anchor": "rename-or-move"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Copy a File",
          "anchor": "copy-a-file"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Change Permissions",
          "anchor": "change-permissions"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Path Security",
          "anchor": "path-security"
        },
        {
          "title": "Common Recipes",
          "anchor": "common-recipes"
        },
        {
          "title": "Scaffold a project directory",
          "anchor": "scaffold-a-project-directory"
        },
        {
          "title": "Retrieve build artifacts",
          "anchor": "retrieve-build-artifacts"
        }
      ],
      "content_excerpt": "The Filesystem API gives you full programmatic access to files and directories inside a running computer. All operations are proxied through the computer command service and restricted to allowed paths.\n\nBase path: `/api/v1/computers/{id}/files`\n\n**Allowed paths:** `/workspace`, `/home`, `/root`, `/tmp`, `/opt`, `/srv`\n\nThe computer must be in `\"running\"` status. Paths outside the allowed prefixes return `403 FORBIDDEN_PATH`.\n\n---\n\n## Quick Start\n```typescript\n\nconst client = new Miosa();\n\n// Wr"
    },
    {
      "slug": "api-reference/invites",
      "path": "/docs/api-reference/invites",
      "url": "https://miosa.ai/docs/api-reference/invites",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/invites",
      "title": "Invites API",
      "description": "API reference for the workspace invite and org invite flows  -  send, list, revoke, preview, and accept email invitations.",
      "source": "src/routes/docs/api-reference/invites/+page.md",
      "headings": [
        {
          "title": "Workspace Invite Endpoints",
          "anchor": "workspace-invite-endpoints"
        },
        {
          "title": "Org Invite Endpoints",
          "anchor": "org-invite-endpoints"
        },
        {
          "title": "Workspace Invite Flow",
          "anchor": "workspace-invite-flow"
        },
        {
          "title": "Send Workspace Invite",
          "anchor": "send-workspace-invite"
        },
        {
          "title": "List Workspace Invites",
          "anchor": "list-workspace-invites"
        },
        {
          "title": "Revoke Workspace Invite",
          "anchor": "revoke-workspace-invite"
        },
        {
          "title": "Preview Workspace Invite (public)",
          "anchor": "preview-workspace-invite-public"
        },
        {
          "title": "Accept Workspace Invite",
          "anchor": "accept-workspace-invite"
        },
        {
          "title": "Org Invite Flow",
          "anchor": "org-invite-flow"
        },
        {
          "title": "Send Org Invite",
          "anchor": "send-org-invite"
        },
        {
          "title": "List Org Invites",
          "anchor": "list-org-invites"
        },
        {
          "title": "Revoke Org Invite",
          "anchor": "revoke-org-invite"
        },
        {
          "title": "Preview Org Invite (public)",
          "anchor": "preview-org-invite-public"
        },
        {
          "title": "Accept Org Invite",
          "anchor": "accept-org-invite"
        },
        {
          "title": "Common Errors",
          "anchor": "common-errors"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "MIOSA has two parallel invite flows:\n\n- **Workspace invites**  -  invite a user to a specific workspace. If the email already belongs to an org member, the user is added directly (no email sent). If not, an invite email is dispatched and accepting it creates both the `tenant_members` and `workspace_members` rows atomically.\n- **Org invites**  -  invite a user to join the org (tenant) without pre-selecting a workspace. The accept step only creates the `tenant_members` row.\n\nBoth flows produce opa"
    },
    {
      "slug": "api-reference/members",
      "path": "/docs/api-reference/members",
      "url": "https://miosa.ai/docs/api-reference/members",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/members",
      "title": "Workspace Members API",
      "description": "API reference for managing workspace member rosters  -  add, remove, and update roles for users inside a workspace.",
      "source": "src/routes/docs/api-reference/members/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Roles",
          "anchor": "roles"
        },
        {
          "title": "List Members",
          "anchor": "list-members"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Add Member",
          "anchor": "add-member"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Update Member Role",
          "anchor": "update-member-role"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Remove Member",
          "anchor": "remove-member"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Common Errors",
          "anchor": "common-errors"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Workspace members are the user roster for a specific workspace. A user must already be an org member (`tenant_members` row) before they can be added to a workspace. The last `owner` in a workspace cannot be removed until another member is promoted to owner.\n\nBase path: `/api/v1/workspaces/:id/members`\n\nTo invite a new user who is not yet an org member, use the [Workspace Invites API](/docs/api-reference/invites) instead. Accepting a workspace invite automatically creates the `tenant_members` row"
    },
    {
      "slug": "api-reference/network-policy",
      "path": "/docs/api-reference/network-policy",
      "url": "https://miosa.ai/docs/api-reference/network-policy",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/network-policy",
      "title": "Network Policy API",
      "description": "API reference for configuring per-computer network access controls on MIOSA computers.",
      "source": "src/routes/docs/api-reference/network-policy/+page.md",
      "headings": [
        {
          "title": "Quick Start",
          "anchor": "quick-start"
        },
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Get Network Policy",
          "anchor": "get-network-policy"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Policy Modes",
          "anchor": "policy-modes"
        },
        {
          "title": "Set Network Policy",
          "anchor": "set-network-policy"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Reset to Default",
          "anchor": "reset-to-default"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Common Recipes",
          "anchor": "common-recipes"
        },
        {
          "title": "Sandbox an untrusted AI task",
          "anchor": "sandbox-an-untrusted-ai-task"
        },
        {
          "title": "Allow only package registries for a build environment",
          "anchor": "allow-only-package-registries-for-a-build-environment"
        },
        {
          "title": "Block a known malicious IP range",
          "anchor": "block-a-known-malicious-ip-range"
        }
      ],
      "content_excerpt": "Network policies control what external hosts and ports a computer can reach. Use them to sandbox untrusted workloads, enforce egress restrictions, or prevent AI agents from making unexpected outbound connections.\n\nBase path: `/api/v1/computers/{id}/network-policy`\n\nNetwork policies apply at the microVM level. Changing a policy takes effect within seconds without restarting the computer.\n\n---\n\n## Quick Start\n```typescript\n\nconst client = new Miosa();\n\n// Restrict to only allow HTTPS to GitHub and"
    },
    {
      "slug": "api-reference/open-computers",
      "path": "/docs/api-reference/open-computers",
      "url": "https://miosa.ai/docs/api-reference/open-computers",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/open-computers",
      "title": "OpenComputers API",
      "description": "Register and control your own machines (BYOC) via the MIOSA API  -  exec, files, tunnels, AI agents, inference clusters, and secrets.",
      "source": "src/routes/docs/api-reference/open-computers/+page.md",
      "headings": [
        {
          "title": "Hosts",
          "anchor": "hosts"
        },
        {
          "title": "List hosts",
          "anchor": "list-hosts"
        },
        {
          "title": "Register a host",
          "anchor": "register-a-host"
        },
        {
          "title": "Get a host",
          "anchor": "get-a-host"
        },
        {
          "title": "Revoke a host",
          "anchor": "revoke-a-host"
        },
        {
          "title": "Host event stream (SSE)",
          "anchor": "host-event-stream-sse"
        },
        {
          "title": "Jobs",
          "anchor": "jobs"
        },
        {
          "title": "Run a job",
          "anchor": "run-a-job"
        },
        {
          "title": "List jobs",
          "anchor": "list-jobs"
        },
        {
          "title": "Get a job",
          "anchor": "get-a-job"
        },
        {
          "title": "Stream job output (SSE)",
          "anchor": "stream-job-output-sse"
        },
        {
          "title": "Cancel a job",
          "anchor": "cancel-a-job"
        },
        {
          "title": "File System",
          "anchor": "file-system"
        },
        {
          "title": "Terminal",
          "anchor": "terminal"
        },
        {
          "title": "Issue a terminal ticket",
          "anchor": "issue-a-terminal-ticket"
        },
        {
          "title": "Desktop (VNC)",
          "anchor": "desktop-vnc"
        },
        {
          "title": "Issue a desktop ticket",
          "anchor": "issue-a-desktop-ticket"
        },
        {
          "title": "Tunnels",
          "anchor": "tunnels"
        },
        {
          "title": "List tunnels",
          "anchor": "list-tunnels"
        },
        {
          "title": "Create a tunnel",
          "anchor": "create-a-tunnel"
        },
        {
          "title": "Get / Update / Delete a tunnel",
          "anchor": "get-update-delete-a-tunnel"
        },
        {
          "title": "Agents",
          "anchor": "agents"
        },
        {
          "title": "Dispatch an agent",
          "anchor": "dispatch-an-agent"
        },
        {
          "title": "List / Get sessions",
          "anchor": "list-get-sessions"
        },
        {
          "title": "Stream agent events (SSE)",
          "anchor": "stream-agent-events-sse"
        },
        {
          "title": "Cancel a session",
          "anchor": "cancel-a-session"
        },
        {
          "title": "Inference Clusters",
          "anchor": "inference-clusters"
        },
        {
          "title": "List clusters",
          "anchor": "list-clusters"
        },
        {
          "title": "Create a cluster",
          "anchor": "create-a-cluster"
        },
        {
          "title": "Get / Start / Stop / Delete",
          "anchor": "get-start-stop-delete"
        },
        {
          "title": "Secrets",
          "anchor": "secrets"
        },
        {
          "title": "Tenant-scoped secrets",
          "anchor": "tenant-scoped-secrets"
        },
        {
          "title": "Host-scoped secrets",
          "anchor": "host-scoped-secrets"
        },
        {
          "title": "SDK Examples",
          "anchor": "sdk-examples"
        },
        {
          "title": "Common Errors",
          "anchor": "common-errors"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "OpenComputers lets you register physical or virtual machines you already own (Mac, Linux, Windows) and control them through MIOSA's API  -  run commands, manage files, expose HTTP tunnels, dispatch AI agents, build inference clusters, and manage secrets.\n\nBase path: `/api/v1/opencomputers`\n\nVerbs supported: **GET** (list/show), **POST** (register/create/exec/dispatch), **PATCH** (update tags/tunnels), **DELETE** (revoke/cancel).\n\nRate limits vary by key, tenant policy, and endpoint family. Honor"
    },
    {
      "slug": "api-reference/preview-tokens",
      "path": "/docs/api-reference/preview-tokens",
      "url": "https://miosa.ai/docs/api-reference/preview-tokens",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/preview-tokens",
      "title": "Preview Tokens API",
      "description": "Generate short-lived signed tokens for iframe embedding without exposing an API key.",
      "source": "src/routes/docs/api-reference/preview-tokens/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Mint a Preview Token",
          "anchor": "mint-a-preview-token"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Scopes",
          "anchor": "scopes"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        },
        {
          "title": "Token Format",
          "anchor": "token-format"
        },
        {
          "title": "Iframe Embedding",
          "anchor": "iframe-embedding"
        }
      ],
      "content_excerpt": "Preview tokens (`mp_*`) are short-lived signed credentials that allow you to embed a running sandbox in an `<iframe>` from a third-party frontend without exposing your `msk_*` API key to the browser.\n\nBase path: `/api/v1/sandboxes/{id}/preview-token`\n\nPreview tokens are single-resource. Each token is scoped to the sandbox it was minted for. Tokens expire after at most 24 hours.\n\n---\n\n## Endpoints\n\n| Method | Path | Description |\n|--------|------|-------------|\n| `POST` | `/api/v1/sandboxes/{id}/"
    },
    {
      "slug": "api-reference/projects",
      "path": "/docs/api-reference/projects",
      "url": "https://miosa.ai/docs/api-reference/projects",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/projects",
      "title": "Projects API",
      "description": "API reference for creating and managing projects inside MIOSA workspaces.",
      "source": "src/routes/docs/api-reference/projects/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "List Projects",
          "anchor": "list-projects"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response - 200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Create a Project",
          "anchor": "create-a-project"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Example",
          "anchor": "example"
        },
        {
          "title": "Response - 201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Get a Project",
          "anchor": "get-a-project"
        },
        {
          "title": "Update a Project",
          "anchor": "update-a-project"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Use Projects on Resource Create",
          "anchor": "use-projects-on-resource-create"
        },
        {
          "title": "Project Preview Domain",
          "anchor": "project-preview-domain"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "A **Project** is the app, website, lead magnet, document, workflow, or customer build inside a workspace. Projects own sandboxes, computers, deployments, databases, storage buckets, volumes, functions, jobs, auth configuration, integrations, and custom domains.\n\nBase path: `/api/v1/projects`\n\nIf a resource create call includes `project_slug`, `project_name`, or `external_project_id`, MIOSA resolves or creates the project before creating the resource. You can also create projects explicitly with "
    },
    {
      "slug": "api-reference/quotas",
      "path": "/docs/api-reference/quotas",
      "url": "https://miosa.ai/docs/api-reference/quotas",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/quotas",
      "title": "Quotas API",
      "description": "Set per-end-user resource limits for white-label multi-tenant deployments.",
      "source": "src/routes/docs/api-reference/quotas/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Get Quota",
          "anchor": "get-quota"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Set Quota",
          "anchor": "set-quota"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Delete Quota",
          "anchor": "delete-quota"
        },
        {
          "title": "Response  -  204 No Content",
          "anchor": "response-204-no-content"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        }
      ],
      "content_excerpt": "Quotas let you cap how many sandboxes an individual end-user of your product can create and run. They are keyed by `external_user_id`  -  the same opaque identifier you pass when creating sandboxes on behalf of your users.\n\nBase path: `/api/v1/quotas/external/{external_user_id}`\n\nQuotas are enforced at sandbox creation time. Setting a quota does not affect sandboxes already running. Deleting a quota removes all limits for that user.\n\n---\n\n## Endpoints\n\n| Method | Path | Description |\n|--------|-"
    },
    {
      "slug": "api-reference/regions",
      "path": "/docs/api-reference/regions",
      "url": "https://miosa.ai/docs/api-reference/regions",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/regions",
      "title": "Regions API",
      "description": "List available regions and pin Computers and Sandboxes to a specific region.",
      "source": "src/routes/docs/api-reference/regions/+page.md",
      "headings": [
        {
          "title": "Overview",
          "anchor": "overview"
        },
        {
          "title": "Available Regions",
          "anchor": "available-regions"
        },
        {
          "title": "Specify a region on create",
          "anchor": "specify-a-region-on-create"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Default region behavior",
          "anchor": "default-region-behavior"
        },
        {
          "title": "List regions",
          "anchor": "list-regions"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Response Fields",
          "anchor": "response-fields"
        },
        {
          "title": "FAQ",
          "anchor": "faq"
        },
        {
          "title": "Why these 3 regions?",
          "anchor": "why-these-3-regions"
        },
        {
          "title": "How do I pick a region?",
          "anchor": "how-do-i-pick-a-region"
        },
        {
          "title": "Can a Computer span multiple regions?",
          "anchor": "can-a-computer-span-multiple-regions"
        },
        {
          "title": "Will more regions ship?",
          "anchor": "will-more-regions-ship"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "MIOSA Computers and Sandboxes run in geographic regions. Every Computer (and every Sandbox, since a Sandbox is a lightweight Computer flavor) is created in exactly one region and stays there for its lifetime.\n\nBase path: `/api/v1/regions`\n\n---\n\n## Overview\n\n- **3 regions are live today.** All have equal status  -  none are preview, none are restricted.\n- **Default region** when you don't specify one: `us-west-la`.\n- **All VM sizes** (XS, S, M, L, XL) are available in every region for both Comput"
    },
    {
      "slug": "api-reference/releases",
      "path": "/docs/api-reference/releases",
      "url": "https://miosa.ai/docs/api-reference/releases",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/releases",
      "title": "Releases API",
      "description": "Inspect and activate exact immutable deployment artifacts.",
      "source": "src/routes/docs/api-reference/releases/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "List releases",
          "anchor": "list-releases"
        },
        {
          "title": "Inspect one release",
          "anchor": "inspect-one-release"
        },
        {
          "title": "Promote one exact release",
          "anchor": "promote-one-exact-release"
        },
        {
          "title": "CLI",
          "anchor": "cli"
        },
        {
          "title": "Immutability",
          "anchor": "immutability"
        },
        {
          "title": "Permissions",
          "anchor": "permissions"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "A **Release** is the immutable artifact produced from a build or sandbox publish.\nIt records the artifact digest, runtime command, port, health check, source attribution, and readiness state used for an exact promotion.\n\nBase path: `/api/v1/deployments/{deployment_id}/releases`\n\n## Endpoints\n\n| Method | Path | Purpose |\n|---|---|---|\n| `GET` | `/deployments/{deployment_id}/releases` | List releases for one deployment |\n| `GET` | `/deployments/{deployment_id}/releases/{release_id}` | Inspect one "
    },
    {
      "slug": "api-reference/runtime-env",
      "path": "/docs/api-reference/runtime-env",
      "url": "https://miosa.ai/docs/api-reference/runtime-env",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/runtime-env",
      "title": "Runtime Env",
      "description": "Store inherited runtime environment variables for sandboxes, computers, agents, and deployments.",
      "source": "src/routes/docs/api-reference/runtime-env/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Create",
          "anchor": "create"
        },
        {
          "title": "Scope model",
          "anchor": "scope-model"
        },
        {
          "title": "CLI",
          "anchor": "cli"
        },
        {
          "title": "Relationship to profiles and connectors",
          "anchor": "relationship-to-profiles-and-connectors"
        },
        {
          "title": "Next",
          "anchor": "next"
        }
      ],
      "content_excerpt": "# Runtime Env\n\nRuntime Env stores inherited environment variables for tenant, workspace, and\nproject scopes. Values are encrypted at rest and are never returned in\nplaintext. MIOSA materializes them into sandboxes, computers, agents, or\ndeployments according to the target you choose.\n\nBase path: `/api/v1/runtime-env`\n\nRuntime Env can hold provider keys such as Anthropic, OpenAI, Higgsfield,\nResend, Stripe, or customer API tokens. Scope them as narrowly as possible and\navoid putting tenant admin "
    },
    {
      "slug": "api-reference/sandbox-env",
      "path": "/docs/api-reference/sandbox-env",
      "url": "https://miosa.ai/docs/api-reference/sandbox-env",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/sandbox-env",
      "title": "Sandbox Env API",
      "description": "CRUD for per-sandbox environment variables, encrypted at rest.",
      "source": "src/routes/docs/api-reference/sandbox-env/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "List Env Vars",
          "anchor": "list-env-vars"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Set Env Vars",
          "anchor": "set-env-vars"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Delete Env Var",
          "anchor": "delete-env-var"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        }
      ],
      "content_excerpt": "The sandbox env API manages a key-value store of environment variables attached to a sandbox. Variables are encrypted at rest and injected into the sandbox process environment on start. The API never returns plaintext values  -  only key names and metadata.\n\nBase path: `/api/v1/sandboxes/{id}/env`\n\nVariable names must match `[A-Z][A-Z0-9_]*`  -  uppercase letters, digits, and underscores, starting with a letter. This mirrors POSIX shell environment variable conventions.\n\n---\n\n## Endpoints\n\n| Met"
    },
    {
      "slug": "api-reference/sandbox-files-advanced",
      "path": "/docs/api-reference/sandbox-files-advanced",
      "url": "https://miosa.ai/docs/api-reference/sandbox-files-advanced",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/sandbox-files-advanced",
      "title": "Sandbox Files (Advanced) API",
      "description": "File tree traversal, batch write, and SSE file-watch for IDE-grade sandbox file operations.",
      "source": "src/routes/docs/api-reference/sandbox-files-advanced/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "File Tree",
          "anchor": "file-tree"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Batch Write",
          "anchor": "batch-write"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "File Watch (SSE)",
          "anchor": "file-watch-sse"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK (text/event-stream)",
          "anchor": "response-200-ok-textevent-stream"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        }
      ],
      "content_excerpt": "These advanced file operations extend the core [Files API](/docs/api-reference/files) with IDE-oriented capabilities: recursive tree listing, atomic batch writes, and a live file-change event stream.\n\nBase path: `/api/v1/sandboxes/{id}/files`\n\nThese routes use `:sandbox_id` as the path parameter internally but are accessed as `/sandboxes/{id}/files/...`  -  the `{id}` segment is the sandbox UUID.\n\n---\n\n## Endpoints\n\n| Method | Path | Description |\n|--------|------|-------------|\n| `GET` | `/api/"
    },
    {
      "slug": "api-reference/sandbox-processes",
      "path": "/docs/api-reference/sandbox-processes",
      "url": "https://miosa.ai/docs/api-reference/sandbox-processes",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/sandbox-processes",
      "title": "Sandbox Processes API",
      "description": "Start, monitor, and stream logs for long-running background processes inside sandboxes.",
      "source": "src/routes/docs/api-reference/sandbox-processes/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Start a Process",
          "anchor": "start-a-process"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "List Processes",
          "anchor": "list-processes"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Get Process Status",
          "anchor": "get-process-status"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Stop a Process",
          "anchor": "stop-a-process"
        },
        {
          "title": "Response  -  204 No Content",
          "anchor": "response-204-no-content"
        },
        {
          "title": "Fetch Logs",
          "anchor": "fetch-logs"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Live Log Stream (SSE)",
          "anchor": "live-log-stream-sse"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        }
      ],
      "content_excerpt": "The processes API lets you launch long-running background commands inside a sandbox and inspect their output  -  useful for starting dev servers, watchers, or any process that runs beyond a single exec call.\n\nBase path: `/api/v1/sandboxes/{id}/processes`\n\nProcesses are managed by the sandbox runtime and survive for the lifetime of the sandbox. They are not preserved across snapshots or forks.\n\n---\n\n## Endpoints\n\n| Method | Path | Description |\n|--------|------|-------------|\n| `POST` | `/api/v1/"
    },
    {
      "slug": "api-reference/sandbox-shares",
      "path": "/docs/api-reference/sandbox-shares",
      "url": "https://miosa.ai/docs/api-reference/sandbox-shares",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/sandbox-shares",
      "title": "Sandbox Shares API",
      "description": "Create and manage public share URLs for sandboxes.",
      "source": "src/routes/docs/api-reference/sandbox-shares/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Create a Share",
          "anchor": "create-a-share"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "List Shares",
          "anchor": "list-shares"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Revoke a Share",
          "anchor": "revoke-a-share"
        },
        {
          "title": "Response  -  204 No Content",
          "anchor": "response-204-no-content"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        }
      ],
      "content_excerpt": "Sandbox shares are publicly accessible URLs that give read-only access to a running sandbox. Unlike preview tokens, share URLs are not scoped to an iframe and do not require the recipient to hold any credentials.\n\nShare tokens use the prefix `ms_` followed by a base64url-encoded payload. The public URL pattern is:\n\n```\nhttps://{sandbox-id}.sandboxes.miosa.ai?ms=ms_<token>\n```\n\n---\n\n## Endpoints\n\n| Method | Path | Description |\n|--------|------|-------------|\n| `POST` | `/api/v1/sandboxes/{id}/sh"
    },
    {
      "slug": "api-reference/sandbox-templates",
      "path": "/docs/api-reference/sandbox-templates",
      "url": "https://miosa.ai/docs/api-reference/sandbox-templates",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/sandbox-templates",
      "title": "Sandbox Templates API",
      "description": "Browse the template marketplace and launch sandboxes from pre-built images.",
      "source": "src/routes/docs/api-reference/sandbox-templates/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "List Templates",
          "anchor": "list-templates"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Get Template",
          "anchor": "get-template"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Create Sandbox from Template",
          "anchor": "create-sandbox-from-template"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        }
      ],
      "content_excerpt": "Sandbox templates are pre-built images with toolchains, dependencies, and configuration baked in. Launching from a template is faster than installing packages at runtime and ensures reproducible environments.\n\nTemplates are read-only marketplace items managed by MIOSA. To build your own custom templates, see the [Templates guide](/docs/develop/templates).\n\n---\n\n## Endpoints\n\n| Method | Path | Description |\n|--------|------|-------------|\n| `GET` | `/api/v1/sandbox-templates` | List available tem"
    },
    {
      "slug": "api-reference/sandboxes",
      "path": "/docs/api-reference/sandboxes",
      "url": "https://miosa.ai/docs/api-reference/sandboxes",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/sandboxes",
      "title": "Sandboxes API",
      "description": "API reference for creating, managing, and executing code in MIOSA sandboxes - persistent-by-default isolated microVM workspaces.",
      "source": "src/routes/docs/api-reference/sandboxes/+page.md",
      "headings": [
        {
          "title": "List sandbox templates and sizes",
          "anchor": "list-sandbox-templates-and-sizes"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Custom templates",
          "anchor": "custom-templates"
        },
        {
          "title": "Configuration and request parameters",
          "anchor": "configuration-and-request-parameters"
        },
        {
          "title": "Create a Sandbox",
          "anchor": "create-a-sandbox"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Request Headers",
          "anchor": "request-headers"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Create and Run",
          "anchor": "create-and-run"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Start a Template App",
          "anchor": "start-a-template-app"
        },
        {
          "title": "Get Artifacts",
          "anchor": "get-artifacts"
        },
        {
          "title": "List Sandboxes",
          "anchor": "list-sandboxes"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Get a Sandbox",
          "anchor": "get-a-sandbox"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Path Parameters",
          "anchor": "path-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Destroy a Sandbox",
          "anchor": "destroy-a-sandbox"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Path Parameters",
          "anchor": "path-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Execute a Command",
          "anchor": "execute-a-command"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Path Parameters",
          "anchor": "path-parameters"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Stream Command Output",
          "anchor": "stream-command-output"
        },
        {
          "title": "Open a Terminal Session",
          "anchor": "open-a-terminal-session"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Export Files",
          "anchor": "export-files"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Expose a Preview Port",
          "anchor": "expose-a-preview-port"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Publish a Sandbox",
          "anchor": "publish-a-sandbox"
        },
        {
          "title": "Promote a Sandbox Runtime to a Deployment",
          "anchor": "promote-a-sandbox-runtime-to-a-deployment"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Upload a File",
          "anchor": "upload-a-file"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Path Parameters",
          "anchor": "path-parameters"
        },
        {
          "title": "Request Body  -  JSON",
          "anchor": "request-body-json"
        },
        {
          "title": "Request Body  -  Multipart",
          "anchor": "request-body-multipart"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Download a File",
          "anchor": "download-a-file"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Path Parameters",
          "anchor": "path-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "List Files",
          "anchor": "list-files"
        },
        {
          "title": "Stat a File",
          "anchor": "stat-a-file"
        },
        {
          "title": "Read Logs",
          "anchor": "read-logs"
        },
        {
          "title": "Extend the Timeout",
          "anchor": "extend-the-timeout"
        },
        {
          "title": "Get Sandbox Usage",
          "anchor": "get-sandbox-usage"
        },
        {
          "title": "Pause and Resume",
          "anchor": "pause-and-resume"
        },
        {
          "title": "Fork a Sandbox",
          "anchor": "fork-a-sandbox"
        },
        {
          "title": "Subscribe to Events (SSE)",
          "anchor": "subscribe-to-events-sse"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Path Parameters",
          "anchor": "path-parameters"
        },
        {
          "title": "Response  -  200 OK (event stream)",
          "anchor": "response-200-ok-event-stream"
        },
        {
          "title": "Sandbox Object",
          "anchor": "sandbox-object"
        },
        {
          "title": "Lifecycle States",
          "anchor": "lifecycle-states"
        },
        {
          "title": "Error Response Format",
          "anchor": "error-response-format"
        },
        {
          "title": "Rate Limits",
          "anchor": "rate-limits"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Sandboxes are persistent-by-default isolated microVM workspaces that restore from pre-seeded snapshots, accept exec and file operations, expose previews, and are billed by compute/runtime usage. They are designed for AI-agent code execution workloads, artifact generation, and app previews.\n\nBase path: `/api/v1/sandboxes`\n\nAll endpoints require `Authorization: Bearer &lt;api_key&gt;`. Get a key from the [MIOSA dashboard](https://miosa.ai/settings/api-keys).\n\nFor higher-level access, use the offic"
    },
    {
      "slug": "api-reference/services",
      "path": "/docs/api-reference/services",
      "url": "https://miosa.ai/docs/api-reference/services",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/services",
      "title": "Services API",
      "description": "API reference for managing long-running systemd services inside MIOSA computers.",
      "source": "src/routes/docs/api-reference/services/+page.md",
      "headings": [
        {
          "title": "Quick Start",
          "anchor": "quick-start"
        },
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Create a Service",
          "anchor": "create-a-service"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Status Values",
          "anchor": "status-values"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "List Services",
          "anchor": "list-services"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Get a Service",
          "anchor": "get-a-service"
        },
        {
          "title": "Path Parameters",
          "anchor": "path-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Start, Stop, Restart",
          "anchor": "start-stop-restart"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Remove a Service",
          "anchor": "remove-a-service"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Common Recipes",
          "anchor": "common-recipes"
        },
        {
          "title": "Deploy a Node.js app as a service",
          "anchor": "deploy-a-nodejs-app-as-a-service"
        },
        {
          "title": "Wait until a service is running",
          "anchor": "wait-until-a-service-is-running"
        },
        {
          "title": "Check for failed services in a fleet",
          "anchor": "check-for-failed-services-in-a-fleet"
        }
      ],
      "content_excerpt": "Services are persistent processes managed by systemd inside a computer. Use them for web servers, background workers, databases, or any daemon that should survive across exec calls and restart automatically on failure.\n\nBase path: `/api/v1/computers/{id}/services`\n\nServices map directly to systemd unit files (`/etc/systemd/system/miosa-{name}.service`) managed by the computer command service. The computer must be **running** to interact with services.\n\n---\n\n## Quick Start\n```typescript\n\nconst cl"
    },
    {
      "slug": "api-reference/snapshots",
      "path": "/docs/api-reference/snapshots",
      "url": "https://miosa.ai/docs/api-reference/snapshots",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/snapshots",
      "title": "Snapshots API",
      "description": "API reference for creating, listing, and restoring microVM snapshots (checkpoints).",
      "source": "src/routes/docs/api-reference/snapshots/+page.md",
      "headings": [
        {
          "title": "Quick Start",
          "anchor": "quick-start"
        },
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Create a Snapshot",
          "anchor": "create-a-snapshot"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Status State Machine",
          "anchor": "status-state-machine"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "List Snapshots",
          "anchor": "list-snapshots"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Get a Snapshot",
          "anchor": "get-a-snapshot"
        },
        {
          "title": "Path Parameters",
          "anchor": "path-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Delete a Snapshot",
          "anchor": "delete-a-snapshot"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Restore from Snapshot",
          "anchor": "restore-from-snapshot"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "SSE Progress Stream",
          "anchor": "sse-progress-stream"
        },
        {
          "title": "Event Types",
          "anchor": "event-types"
        },
        {
          "title": "Common Recipes",
          "anchor": "common-recipes"
        },
        {
          "title": "Automated checkpoint before risky operations",
          "anchor": "automated-checkpoint-before-risky-operations"
        },
        {
          "title": "Snapshot-based parallelism (clone a baseline)",
          "anchor": "snapshot-based-parallelism-clone-a-baseline"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Snapshots capture the full in-memory state of a running computer  -  CPU state, RAM, and filesystem  -  and store it durably. Restore a snapshot to spin up an identical computer in seconds.\n\nThis page documents desktop Computer snapshots only.\nCanonical sandbox V1 does not expose direct snapshot CRUD; use [Persistence, pause, and forks](/docs/develop/snapshots/) and the [fork endpoint](/docs/api-reference/sandboxes/#fork-a-sandbox).\n\nBase path: `/api/v1/computers/{id}/snapshots`\n\nSnapshots requi"
    },
    {
      "slug": "api-reference/streaming-exec",
      "path": "/docs/api-reference/streaming-exec",
      "url": "https://miosa.ai/docs/api-reference/streaming-exec",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/streaming-exec",
      "title": "Streaming Exec API",
      "description": "API reference for streaming command output in real-time from MIOSA computers via SSE.",
      "source": "src/routes/docs/api-reference/streaming-exec/+page.md",
      "headings": [
        {
          "title": "Quick Start",
          "anchor": "quick-start"
        },
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Start Streaming Exec",
          "anchor": "start-streaming-exec"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  202 Accepted",
          "anchor": "response-202-accepted"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Connect to SSE Stream",
          "anchor": "connect-to-sse-stream"
        },
        {
          "title": "Event Types",
          "anchor": "event-types"
        },
        {
          "title": "Event Payload Examples",
          "anchor": "event-payload-examples"
        },
        {
          "title": "stream Values",
          "anchor": "stream-values"
        },
        {
          "title": "Comparison: Streaming vs Non-Streaming",
          "anchor": "comparison-streaming-vs-non-streaming"
        },
        {
          "title": "Common Recipes",
          "anchor": "common-recipes"
        },
        {
          "title": "Monitor a build",
          "anchor": "monitor-a-build"
        },
        {
          "title": "Capture both streams separately",
          "anchor": "capture-both-streams-separately"
        },
        {
          "title": "Timeout handling",
          "anchor": "timeout-handling"
        }
      ],
      "content_excerpt": "Streaming exec runs a command on a computer and delivers output line-by-line via Server-Sent Events. Use it for long-running builds, installs, or any command where you want incremental output rather than waiting for completion.\n\nBase path: `/api/v1/computers/{id}/exec/stream`\n\nStandard `POST /computers/{id}/exec` waits for the command to finish before returning. Streaming exec is better for commands that run longer than a few seconds or that you want to monitor interactively.\n\n---\n\n## Quick Star"
    },
    {
      "slug": "api-reference/tenant-branding",
      "path": "/docs/api-reference/tenant-branding",
      "url": "https://miosa.ai/docs/api-reference/tenant-branding",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/tenant-branding",
      "title": "Tenant Branding API",
      "description": "Customize the logo, name, and colors shown on sandbox 404 and 502 error pages.",
      "source": "src/routes/docs/api-reference/tenant-branding/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Get Branding",
          "anchor": "get-branding"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Set Branding",
          "anchor": "set-branding"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Delete Branding",
          "anchor": "delete-branding"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        }
      ],
      "content_excerpt": "The branding API controls the appearance of proxy-generated error pages (404, 502, gateway timeout) served within your custom preview domain. Set your logo, product name, support URL, and primary accent color so end-users see your brand  -  not MIOSA's.\n\nBase path: `/api/v1/tenant/branding`\n\nBranding changes are served immediately from cache. There is no propagation delay.\n\n---\n\n## Endpoints\n\n| Method | Path | Description |\n|--------|------|-------------|\n| `GET` | `/api/v1/tenant/branding` | Ge"
    },
    {
      "slug": "api-reference/tenant-events",
      "path": "/docs/api-reference/tenant-events",
      "url": "https://miosa.ai/docs/api-reference/tenant-events",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/tenant-events",
      "title": "Tenant Events (SSE) API",
      "description": "Subscribe to a real-time server-sent event stream of all tenant-wide platform events.",
      "source": "src/routes/docs/api-reference/tenant-events/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Open Event Stream",
          "anchor": "open-event-stream"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK (text/event-stream)",
          "anchor": "response-200-ok-textevent-stream"
        },
        {
          "title": "Event Shape",
          "anchor": "event-shape"
        },
        {
          "title": "Event Types",
          "anchor": "event-types"
        },
        {
          "title": "Sandbox Events",
          "anchor": "sandbox-events"
        },
        {
          "title": "Computer Events",
          "anchor": "computer-events"
        },
        {
          "title": "Deployment Events",
          "anchor": "deployment-events"
        },
        {
          "title": "Webhook Events",
          "anchor": "webhook-events"
        },
        {
          "title": "Filtering with types",
          "anchor": "filtering-with-types"
        },
        {
          "title": "Reconnection",
          "anchor": "reconnection"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        }
      ],
      "content_excerpt": "The tenant events stream delivers real-time Server-Sent Events (SSE) for all activity across your tenant  -  sandbox lifecycle changes, deployments, webhook deliveries, and more. Subscribe once and receive events for all your resources.\n\nBase path: `/api/v1/events/stream`\n\nThis endpoint uses `text/event-stream` (SSE). Set `Accept: text/event-stream` on your request, or use a native `EventSource` client.\n\nThe `Authorization` header cannot be set by browser `EventSource`. Use a server-side client "
    },
    {
      "slug": "api-reference/tenant-preview-domain",
      "path": "/docs/api-reference/tenant-preview-domain",
      "url": "https://miosa.ai/docs/api-reference/tenant-preview-domain",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/tenant-preview-domain",
      "title": "Tenant Preview Domain API",
      "description": "Configure a custom apex domain for sandbox preview URLs (white-label).",
      "source": "src/routes/docs/api-reference/tenant-preview-domain/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Get Preview Domain",
          "anchor": "get-preview-domain"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Response  -  200 OK (domain configured)",
          "anchor": "response-200-ok-domain-configured"
        },
        {
          "title": "Response  -  200 OK (not configured)",
          "anchor": "response-200-ok-not-configured"
        },
        {
          "title": "Set Preview Domain",
          "anchor": "set-preview-domain"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "DNS Setup",
          "anchor": "dns-setup"
        },
        {
          "title": "Verify DNS",
          "anchor": "verify-dns"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Delete Preview Domain",
          "anchor": "delete-preview-domain"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        }
      ],
      "content_excerpt": "The preview domain API lets you map your own apex domain (e.g. `cliniciq.com`) to sandbox preview URLs. When configured, sandboxes created under your tenant will be accessible at `{sandbox-slug}.{your-domain}` instead of the default `*.sandbox.miosa.ai`.\n\n**Auth note:** These endpoints accept both `msk_*` API keys and JWT tokens. This matters for white-label integrations where you programmatically manage the domain from a backend service.\n\nOnly apex domains are accepted (e.g. `cliniciq.com`, not"
    },
    {
      "slug": "api-reference/usage-rollup",
      "path": "/docs/api-reference/usage-rollup",
      "url": "https://miosa.ai/docs/api-reference/usage-rollup",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/usage-rollup",
      "title": "Usage Rollup API",
      "description": "Aggregate sandbox compute usage and spend by external user, project, or workspace.",
      "source": "src/routes/docs/api-reference/usage-rollup/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Get Usage Rollup",
          "anchor": "get-usage-rollup"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        }
      ],
      "content_excerpt": "The usage rollup endpoint aggregates metered usage across sandboxes and computers, grouped by an identifier of your choice. Use it to build per-user billing dashboards, enforce spend policies, or attribute costs to projects.\n\nBase path: `/api/v1/usage`\n\nResults are limited to 1000 rows per request. For high-cardinality tenants, narrow the period or use a more specific `group_by`.\n\n---\n\n## Endpoints\n\n| Method | Path | Description |\n|--------|------|-------------|\n| `GET` | `/api/v1/usage` | Aggre"
    },
    {
      "slug": "api-reference/versions",
      "path": "/docs/api-reference/versions",
      "url": "https://miosa.ai/docs/api-reference/versions",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/versions",
      "title": "API Reference / Versions",
      "description": "Immutable deployment version sub-resource. List, get, promote, archive.",
      "source": "src/routes/docs/api-reference/versions/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "List",
          "anchor": "list"
        },
        {
          "title": "Get",
          "anchor": "get"
        },
        {
          "title": "Promote",
          "anchor": "promote"
        },
        {
          "title": "States",
          "anchor": "states"
        },
        {
          "title": "Permissions",
          "anchor": "permissions"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "A **Deployment Version** is the immutable record of one publish. See [Versions](/docs/deploy/versions/) for the conceptual model.\n\n## Endpoints\n```http\nGET  /api/v1/deployments/:id/versions\nGET  /api/v1/deployments/:id/versions/:version_id\nPOST /api/v1/deployments/:id/versions/:version_id/promote\n```\n\n## List\n```http\nGET /api/v1/deployments/:id/versions\nGET /api/v1/deployments/:id/versions?state=ready\nGET /api/v1/deployments/:id/versions?workspace_id=550e8400-e29b-41d4-a716-446655440000\nGET /api"
    },
    {
      "slug": "api-reference/webhooks",
      "path": "/docs/api-reference/webhooks",
      "url": "https://miosa.ai/docs/api-reference/webhooks",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/webhooks",
      "title": "Webhooks API",
      "description": "Subscribe to platform lifecycle events via outgoing HTTP callbacks with HMAC signature verification.",
      "source": "src/routes/docs/api-reference/webhooks/+page.md",
      "headings": [
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "List Webhooks",
          "anchor": "list-webhooks"
        },
        {
          "title": "Auth",
          "anchor": "auth"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Create a Webhook",
          "anchor": "create-a-webhook"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Update a Webhook",
          "anchor": "update-a-webhook"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Delete a Webhook",
          "anchor": "delete-a-webhook"
        },
        {
          "title": "Response  -  204 No Content",
          "anchor": "response-204-no-content"
        },
        {
          "title": "Send a Test Delivery",
          "anchor": "send-a-test-delivery"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "List Deliveries",
          "anchor": "list-deliveries"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Signature Verification",
          "anchor": "signature-verification"
        },
        {
          "title": "Example verification (Python)",
          "anchor": "example-verification-python"
        },
        {
          "title": "Example verification (TypeScript)",
          "anchor": "example-verification-typescript"
        },
        {
          "title": "Retry Policy",
          "anchor": "retry-policy"
        },
        {
          "title": "Subscribed Event Types",
          "anchor": "subscribed-event-types"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        }
      ],
      "content_excerpt": "Webhooks fire outgoing HTTP POST requests to your endpoint when platform events occur  -  sandbox lifecycle changes, deployment completions, billing events, and more. Each delivery is signed with HMAC-SHA256 so you can verify authenticity.\n\nBase path: `/api/v1/webhooks`\n\nThe webhook `secret` is returned **only once**  -  in the response to `POST /webhooks`. Store it immediately in a secure location. It cannot be retrieved later (only a masked preview is shown afterward).\n\n---\n\n## Endpoints\n\n| Me"
    },
    {
      "slug": "api-reference/workspaces",
      "path": "/docs/api-reference/workspaces",
      "url": "https://miosa.ai/docs/api-reference/workspaces",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/api-reference/workspaces",
      "title": "Workspaces API",
      "description": "API reference for creating and managing MIOSA workspaces - the customer/client layer inside an organization.",
      "source": "src/routes/docs/api-reference/workspaces/+page.md",
      "headings": [
        {
          "title": "Quick Start",
          "anchor": "quick-start"
        },
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "List Workspaces",
          "anchor": "list-workspaces"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Create a Workspace",
          "anchor": "create-a-workspace"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  201 Created",
          "anchor": "response-201-created"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Get a Workspace",
          "anchor": "get-a-workspace"
        },
        {
          "title": "Path Parameters",
          "anchor": "path-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Update a Workspace",
          "anchor": "update-a-workspace"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Delete a Workspace",
          "anchor": "delete-a-workspace"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Update Workspace Settings",
          "anchor": "update-workspace-settings"
        },
        {
          "title": "Request Body",
          "anchor": "request-body"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Workspace Preview Domain",
          "anchor": "workspace-preview-domain"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "List Computers in a Workspace",
          "anchor": "list-computers-in-a-workspace"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "List Projects in a Workspace",
          "anchor": "list-projects-in-a-workspace"
        },
        {
          "title": "Response - 200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Get Workspace Stats",
          "anchor": "get-workspace-stats"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Get Workspace Usage",
          "anchor": "get-workspace-usage"
        },
        {
          "title": "Query Parameters",
          "anchor": "query-parameters"
        },
        {
          "title": "Response  -  200 OK",
          "anchor": "response-200-ok"
        },
        {
          "title": "Errors",
          "anchor": "errors"
        },
        {
          "title": "Common Recipes",
          "anchor": "common-recipes"
        },
        {
          "title": "Move all computers to a new workspace",
          "anchor": "move-all-computers-to-a-new-workspace"
        },
        {
          "title": "Enumerate all workspaces and their sizes",
          "anchor": "enumerate-all-workspaces-and-their-sizes"
        },
        {
          "title": "Default workspace ID lookup",
          "anchor": "default-workspace-id-lookup"
        },
        {
          "title": "Common Errors",
          "anchor": "common-errors"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Workspaces group resources inside an organization. In a white-label platform, a workspace usually represents one downstream customer or client, such as `Dr. Smith Clinic` inside the `ClinicIQ` organization. Projects live inside workspaces, and sandboxes, computers, deployments, databases, storage buckets, volumes, functions, jobs, and domains belong to projects.\n\nBase path: `/api/v1/workspaces`\n\nA **default** workspace is created automatically when you sign up. Resources are assigned to the defa"
    },
    {
      "slug": "authentication",
      "path": "/docs/authentication",
      "url": "https://miosa.ai/docs/authentication",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/authentication",
      "title": "Authentication",
      "description": "How to authenticate with the MIOSA API using msk_ API keys or JWT tokens.",
      "source": "src/routes/docs/authentication/+page.md",
      "headings": [
        {
          "title": "Credential hierarchy",
          "anchor": "credential-hierarchy"
        },
        {
          "title": "API Keys",
          "anchor": "api-keys"
        },
        {
          "title": "Key format",
          "anchor": "key-format"
        },
        {
          "title": "Creating an API key",
          "anchor": "creating-an-api-key"
        },
        {
          "title": "Using an API key",
          "anchor": "using-an-api-key"
        },
        {
          "title": "Managing keys",
          "anchor": "managing-keys"
        },
        {
          "title": "Admin keys",
          "anchor": "admin-keys"
        },
        {
          "title": "Preview tokens",
          "anchor": "preview-tokens"
        },
        {
          "title": "Minting a preview token",
          "anchor": "minting-a-preview-token"
        },
        {
          "title": "Share tokens",
          "anchor": "share-tokens"
        },
        {
          "title": "Minting a share URL",
          "anchor": "minting-a-share-url"
        },
        {
          "title": "Token comparison",
          "anchor": "token-comparison"
        },
        {
          "title": "White-label auth note",
          "anchor": "white-label-auth-note"
        },
        {
          "title": "JWT Tokens",
          "anchor": "jwt-tokens"
        },
        {
          "title": "Obtaining a token",
          "anchor": "obtaining-a-token"
        },
        {
          "title": "Token lifecycle",
          "anchor": "token-lifecycle"
        },
        {
          "title": "SSE streams",
          "anchor": "sse-streams"
        },
        {
          "title": "Rate limits",
          "anchor": "rate-limits"
        },
        {
          "title": "Error codes",
          "anchor": "error-codes"
        },
        {
          "title": "Security best practices",
          "anchor": "security-best-practices"
        }
      ],
      "content_excerpt": "# Authentication\n\nEvery MIOSA API request carries a single `Authorization: Bearer &lt;token&gt;` header.\nThe token is either an **API key** (prefix `msk_`) or a **JWT** from `POST /auth/login`.\n\nOne key covers the entire platform  -  computers, desktop, files, exec, CUA agent,\nOSA, credits, and (with the right role) admin. No separate keys for AI, no\nper-product configuration.\n\n## Credential hierarchy\n\nDiagram:\ngraph TB\n    MSK[msk_* workspace key] -->|server-side only| API[MIOSA API calls]\n    "
    },
    {
      "slug": "availability",
      "path": "/docs/availability",
      "url": "https://miosa.ai/docs/availability",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/availability",
      "title": "Availability & Roadmap",
      "description": "Current MIOSA product availability, what is generally available, what is in hardening, and what is planned next.",
      "source": "src/routes/docs/availability/+page.md",
      "headings": [
        {
          "title": "Release stages",
          "anchor": "release-stages"
        },
        {
          "title": "Generally available",
          "anchor": "generally-available"
        },
        {
          "title": "Partner preview",
          "anchor": "partner-preview"
        },
        {
          "title": "In hardening",
          "anchor": "in-hardening"
        },
        {
          "title": "Planned",
          "anchor": "planned"
        },
        {
          "title": "Deliberate product boundaries",
          "anchor": "deliberate-product-boundaries"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Availability & Roadmap\n\nThis page gives customers a clean read on what is ready for production today, what is available for selected partners, and what is still on the roadmap.\n\nLast updated: 2026-07-25.\nWe update this page when a platform capability changes release stage.\n\n## Release stages\n\n| Stage | Meaning |\n|---|---|\n| **Generally available** | Supported for production use with documented APIs and normal support paths. |\n| **Partner preview** | Available to approved customers while we fin"
    },
    {
      "slug": "benchmarks",
      "path": "/docs/benchmarks",
      "url": "https://miosa.ai/docs/benchmarks",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/benchmarks",
      "title": "Benchmarks",
      "description": "Verified MIOSA performance results.",
      "source": "src/routes/docs/benchmarks/+page.md",
      "headings": [],
      "content_excerpt": "# Benchmarks\n\nNew benchmark results are coming soon."
    },
    {
      "slug": "changelog",
      "path": "/docs/changelog",
      "url": "https://miosa.ai/docs/changelog",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/changelog",
      "title": "Changelog",
      "description": "Customer-facing updates to MIOSA products, platform capabilities, SDKs, CLI tools, and documentation.",
      "source": "src/routes/docs/changelog/+page.md",
      "headings": [
        {
          "title": "August 10, 2026",
          "anchor": "august-10-2026"
        },
        {
          "title": "Clearer documentation navigation",
          "anchor": "clearer-documentation-navigation"
        },
        {
          "title": "A clearer path from idea to production",
          "anchor": "a-clearer-path-from-idea-to-production"
        },
        {
          "title": "Operational documentation and safer discovery",
          "anchor": "operational-documentation-and-safer-discovery"
        },
        {
          "title": "Documentation search",
          "anchor": "documentation-search"
        },
        {
          "title": "Guided learning paths and clearer terminology",
          "anchor": "guided-learning-paths-and-clearer-terminology"
        },
        {
          "title": "August 9, 2026",
          "anchor": "august-9-2026"
        },
        {
          "title": "A clearer documentation experience",
          "anchor": "a-clearer-documentation-experience"
        },
        {
          "title": "Domain setup and deployment URLs",
          "anchor": "domain-setup-and-deployment-urls"
        },
        {
          "title": "Onboarding improvements",
          "anchor": "onboarding-improvements"
        },
        {
          "title": "August 5 - 8, 2026",
          "anchor": "august-5-8-2026"
        },
        {
          "title": "Faster, more dependable computers",
          "anchor": "faster-more-dependable-computers"
        },
        {
          "title": "Account and organization access",
          "anchor": "account-and-organization-access"
        },
        {
          "title": "API key and CLI guidance",
          "anchor": "api-key-and-cli-guidance"
        },
        {
          "title": "July 29 - August 1, 2026",
          "anchor": "july-29-august-1-2026"
        },
        {
          "title": "App Engine and deployment workflows",
          "anchor": "app-engine-and-deployment-workflows"
        },
        {
          "title": "Sandboxes and operational access",
          "anchor": "sandboxes-and-operational-access"
        },
        {
          "title": "Data and integrations",
          "anchor": "data-and-integrations"
        },
        {
          "title": "Workspace-scoped assistance",
          "anchor": "workspace-scoped-assistance"
        },
        {
          "title": "July 24, 2026",
          "anchor": "july-24-2026"
        },
        {
          "title": "Public contracts and deployment guidance",
          "anchor": "public-contracts-and-deployment-guidance"
        },
        {
          "title": "Usage and platform controls",
          "anchor": "usage-and-platform-controls"
        },
        {
          "title": "July 7 - 19, 2026",
          "anchor": "july-7-19-2026"
        },
        {
          "title": "Production workflows",
          "anchor": "production-workflows"
        },
        {
          "title": "May - June 2026",
          "anchor": "may-june-2026"
        },
        {
          "title": "Platform foundation",
          "anchor": "platform-foundation"
        }
      ],
      "content_excerpt": "# Changelog\n\nThis page highlights meaningful improvements after they are available to customers.\n\nEntries focus on the product result, affected workflow, and any action customers should take.\n\nInternal infrastructure details, private identifiers, security-sensitive implementation notes, and routine maintenance are intentionally excluded.\n\nPlanned work belongs in [Availability & Roadmap](/docs/availability/), not in the changelog.\n\nUnless an entry includes an action notice, existing projects and "
    },
    {
      "slug": "cli",
      "path": "/docs/cli",
      "url": "https://miosa.ai/docs/cli",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/cli",
      "title": "CLI Reference",
      "description": "Install, authenticate, inspect capabilities, build in sandboxes, and promote exact immutable MIOSA releases.",
      "source": "src/routes/docs/cli/+page.md",
      "headings": [
        {
          "title": "Install",
          "anchor": "install"
        },
        {
          "title": "Authenticate",
          "anchor": "authenticate"
        },
        {
          "title": "Discover the current contract",
          "anchor": "discover-the-current-contract"
        },
        {
          "title": "Scope and context",
          "anchor": "scope-and-context"
        },
        {
          "title": "Diagnose the local CLI",
          "anchor": "diagnose-the-local-cli"
        },
        {
          "title": "Inspect and plan a local application",
          "anchor": "inspect-and-plan-a-local-application"
        },
        {
          "title": "Create a sandbox",
          "anchor": "create-a-sandbox"
        },
        {
          "title": "Files and commands",
          "anchor": "files-and-commands"
        },
        {
          "title": "Services, environment, and previews",
          "anchor": "services-environment-and-previews"
        },
        {
          "title": "Sandbox snapshots",
          "anchor": "sandbox-snapshots"
        },
        {
          "title": "Publish a new App Engine deployment",
          "anchor": "publish-a-new-app-engine-deployment"
        },
        {
          "title": "Publish an update to an existing deployment",
          "anchor": "publish-an-update-to-an-existing-deployment"
        },
        {
          "title": "Inspect, promote, and roll back releases",
          "anchor": "inspect-promote-and-roll-back-releases"
        },
        {
          "title": "Prove production",
          "anchor": "prove-production"
        },
        {
          "title": "Managed databases",
          "anchor": "managed-databases"
        },
        {
          "title": "Capability contracts and durable operations",
          "anchor": "capability-contracts-and-durable-operations"
        },
        {
          "title": "Templates",
          "anchor": "templates"
        },
        {
          "title": "Computers and OpenComputers",
          "anchor": "computers-and-opencomputers"
        },
        {
          "title": "Agent runs and runtime configuration",
          "anchor": "agent-runs-and-runtime-configuration"
        },
        {
          "title": "API tokens",
          "anchor": "api-tokens"
        },
        {
          "title": "Shell completion",
          "anchor": "shell-completion"
        },
        {
          "title": "Update",
          "anchor": "update"
        },
        {
          "title": "Next",
          "anchor": "next"
        }
      ],
      "content_excerpt": "The MIOSA CLI is the canonical terminal workflow for sandbox development, application publishing, exact release promotion, deployment proof, managed databases, Computers, and OpenComputers.\n\nRegistry version verified on August 8, 2026: `@miosa/cli@1.1.14`.\n\n## Install\n\n```bash\nnpm install --global @miosa/cli@latest\nmiosa version\n```\n\nUse the Node CLI distributed through npm.\nIf another executable named `miosa` is installed, verify which binary your shell resolves:\n\n```bash\ncommand -v miosa\nmiosa"
    },
    {
      "slug": "component-library",
      "path": "/docs/component-library",
      "url": "https://miosa.ai/docs/component-library",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/component-library",
      "title": "Foundation Component Library",
      "description": "MIOSA Foundation UI reference with design intent, Tailwind v4 tokens, CSS variables, and design tokens.",
      "source": "src/routes/docs/component-library/+page.md",
      "headings": [
        {
          "title": "What Lives Where",
          "anchor": "what-lives-where"
        },
        {
          "title": "Compact Reference",
          "anchor": "compact-reference"
        },
        {
          "title": "Extended Reference",
          "anchor": "extended-reference"
        },
        {
          "title": "Design Character",
          "anchor": "design-character"
        },
        {
          "title": "Keep",
          "anchor": "keep"
        },
        {
          "title": "Remove Or Merge",
          "anchor": "remove-or-merge"
        },
        {
          "title": "Component Quality Bar",
          "anchor": "component-quality-bar"
        },
        {
          "title": "Component Cleanup Checklist",
          "anchor": "component-cleanup-checklist"
        },
        {
          "title": "See Also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "MIOSA Foundation is the internal component library for the platform frontend. It is the place to inspect components before deciding what to keep, remove, rename, or rebuild.\n\nThe live browser is maintained in the Foundation package:\n\n```bash\ncd miosa-platform/miosa-frontend/src/lib/foundations-components\nnpm run dev -- --host 127.0.0.1 --port 5174\n```\n\nOpen:\n\n```text\nhttp://127.0.0.1:5174/component-library\n```\n\nThe library is being cleaned up from a broad prototype set into a small, repeatable M"
    },
    {
      "slug": "computers/byoc",
      "path": "/docs/computers/byoc",
      "url": "https://miosa.ai/docs/computers/byoc",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/computers/byoc",
      "title": "BYOC / OpenComputers",
      "description": "Register your own hardware (Mac, Linux, Windows). One command, your machine becomes a MIOSA computer. Apache 2.0.",
      "source": "src/routes/docs/computers/byoc/+page.md",
      "headings": [
        {
          "title": "Why BYOC",
          "anchor": "why-byoc"
        },
        {
          "title": "Install the agent (one command)",
          "anchor": "install-the-agent-one-command"
        },
        {
          "title": "Three modes",
          "anchor": "three-modes"
        },
        {
          "title": "Use a BYOC computer",
          "anchor": "use-a-byoc-computer"
        },
        {
          "title": "Tunnels",
          "anchor": "tunnels"
        },
        {
          "title": "Resource control",
          "anchor": "resource-control"
        },
        {
          "title": "Health and reliability",
          "anchor": "health-and-reliability"
        },
        {
          "title": "Security",
          "anchor": "security"
        },
        {
          "title": "Pricing",
          "anchor": "pricing"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "**OpenComputers** is MIOSA's bring-your-own-compute path. Install the agent on your own hardware  -  laptops, desktops, mini-PCs, even Raspberry Pi for light workloads  -  and it registers with MIOSA over an outbound WebSocket. Your machine becomes a MIOSA computer that you (or your AI agents) can drive through the same API as cloud computers.\n\nApache 2.0. Local-first scheduling  -  work runs on your hardware when there's capacity; cloud overflow when there isn't.\n\n## Why BYOC\n\n- **Already own t"
    },
    {
      "slug": "computers/desktop",
      "path": "/docs/computers/desktop",
      "url": "https://miosa.ai/docs/computers/desktop",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/computers/desktop",
      "title": "Desktop Control",
      "description": "Programmatic desktop control for MIOSA Computers, including screenshots, mouse, keyboard, clipboard, windows, accessibility, shell, and files.",
      "source": "src/routes/docs/computers/desktop/+page.md",
      "headings": [
        {
          "title": "Control surfaces",
          "anchor": "control-surfaces"
        },
        {
          "title": "First real loop",
          "anchor": "first-real-loop"
        },
        {
          "title": "Desktop methods",
          "anchor": "desktop-methods"
        },
        {
          "title": "Coordinate system",
          "anchor": "coordinate-system"
        },
        {
          "title": "The control loop",
          "anchor": "the-control-loop"
        },
        {
          "title": "Screen",
          "anchor": "screen"
        },
        {
          "title": "screenshot()",
          "anchor": "screenshot"
        },
        {
          "title": "screenshotbase64()",
          "anchor": "screenshotbase64"
        },
        {
          "title": "Click",
          "anchor": "click"
        },
        {
          "title": "click(x, y)",
          "anchor": "clickx-y"
        },
        {
          "title": "leftclick(x, y)",
          "anchor": "leftclickx-y"
        },
        {
          "title": "rightclick(x, y)",
          "anchor": "rightclickx-y"
        },
        {
          "title": "doubleclick(x, y)",
          "anchor": "doubleclickx-y"
        },
        {
          "title": "Mouse",
          "anchor": "mouse"
        },
        {
          "title": "movecursor(x, y)",
          "anchor": "movecursorx-y"
        },
        {
          "title": "mousedown(x, y) / mouseup(x, y)",
          "anchor": "mousedownx-y-mouseupx-y"
        },
        {
          "title": "drag(fromx, fromy, tox, toy)",
          "anchor": "dragfromx-fromy-tox-toy"
        },
        {
          "title": "Keyboard",
          "anchor": "keyboard"
        },
        {
          "title": "type(text)",
          "anchor": "typetext"
        },
        {
          "title": "key(key)",
          "anchor": "keykey"
        },
        {
          "title": "hotkey(keys)",
          "anchor": "hotkeykeys"
        },
        {
          "title": "keydown(key) / keyup(key)",
          "anchor": "keydownkey-keyupkey"
        },
        {
          "title": "Scroll",
          "anchor": "scroll"
        },
        {
          "title": "scroll(direction, clicks)",
          "anchor": "scrolldirection-clicks"
        },
        {
          "title": "Convenience scrolls",
          "anchor": "convenience-scrolls"
        },
        {
          "title": "Clipboard",
          "anchor": "clipboard"
        },
        {
          "title": "getclipboard()",
          "anchor": "getclipboard"
        },
        {
          "title": "setclipboard(text)",
          "anchor": "setclipboardtext"
        },
        {
          "title": "Screen info",
          "anchor": "screen-info"
        },
        {
          "title": "getscreensize()",
          "anchor": "getscreensize"
        },
        {
          "title": "getcursorposition()",
          "anchor": "getcursorposition"
        },
        {
          "title": "Windows",
          "anchor": "windows"
        },
        {
          "title": "windows()",
          "anchor": "windows"
        },
        {
          "title": "launch(app)",
          "anchor": "launchapp"
        },
        {
          "title": "focuswindow(id) / get/setwindowsize(id, ...) / get/setwindowposition(id, ...) / maximizewindow(id) / minimizewindow(id) / closewindow(id)",
          "anchor": "focuswindowid-getsetwindowsizeid-getsetwindowpositionid-maximizewindowid-minimizewindowid-closewindowid"
        },
        {
          "title": "Environment",
          "anchor": "environment"
        },
        {
          "title": "getdesktopenvironment()",
          "anchor": "getdesktopenvironment"
        },
        {
          "title": "setwallpaper(path)",
          "anchor": "setwallpaperpath"
        },
        {
          "title": "getaccessibilitytree()",
          "anchor": "getaccessibilitytree"
        },
        {
          "title": "Shell",
          "anchor": "shell"
        },
        {
          "title": "bash(cmd)",
          "anchor": "bashcmd"
        },
        {
          "title": "python(code)",
          "anchor": "pythoncode"
        },
        {
          "title": "writefile(path, content)",
          "anchor": "writefilepath-content"
        },
        {
          "title": "readfile(path)",
          "anchor": "readfilepath"
        },
        {
          "title": "Agent reasoning loop",
          "anchor": "agent-reasoning-loop"
        },
        {
          "title": "Full agent loop example",
          "anchor": "full-agent-loop-example"
        },
        {
          "title": "Latency reference",
          "anchor": "latency-reference"
        },
        {
          "title": "Authentication",
          "anchor": "authentication"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Once you have a [Computer](/docs/computers/overview/), Desktop Control is how software operates the same screen a human would see.\nUse it to inspect the current state, take one action, verify the result, and continue.\nThat loop is what keeps browser agents, computer-use models, custom RPA, and operator tooling grounded in the real machine.\n\nUse Desktop Control when the task needs a real GUI, a logged-in browser session, pixels, files, windows, clipboard state, or accessibility structure.\nUse a ["
    },
    {
      "slug": "computers/embedding",
      "path": "/docs/computers/embedding",
      "url": "https://miosa.ai/docs/computers/embedding",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/computers/embedding",
      "title": "Embedding & Streaming",
      "description": "Embed a live Computer desktop in your own UI with a short-lived stream URL. Pixel streaming and input forwarding are handled by MIOSA.",
      "source": "src/routes/docs/computers/embedding/+page.md",
      "headings": [
        {
          "title": "The flow",
          "anchor": "the-flow"
        },
        {
          "title": "Get an embed URL",
          "anchor": "get-an-embed-url"
        },
        {
          "title": "Embed",
          "anchor": "embed"
        },
        {
          "title": "What's streamed",
          "anchor": "whats-streamed"
        },
        {
          "title": "Read-only mode",
          "anchor": "read-only-mode"
        },
        {
          "title": "Bandwidth",
          "anchor": "bandwidth"
        },
        {
          "title": "Lifetime",
          "anchor": "lifetime"
        },
        {
          "title": "Custom domains / branded streaming",
          "anchor": "custom-domains-branded-streaming"
        },
        {
          "title": "CSP",
          "anchor": "csp"
        },
        {
          "title": "Audit",
          "anchor": "audit"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "To show a live desktop session in your end-user's browser, embed MIOSA's desktop stream.\nUse this for \"watch the AI work\" UI, manual takeover, internal support tools, and kiosk-style apps.\n\n## The flow\n```\n\n1. Your backend asks MIOSA for signed Computer URLs or a stream token for a running computer\n2. MIOSA returns a short-lived desktop URL or token\n3. Your frontend renders an iframe with that URL\n4. The user sees the live desktop; keyboard/mouse input is forwarded into the VM\n```\n\n## Get an emb"
    },
    {
      "slug": "computers/fast-start",
      "path": "/docs/computers/fast-start",
      "url": "https://miosa.ai/docs/computers/fast-start",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/computers/fast-start",
      "title": "Fast start & readiness",
      "description": "How MIOSA starts managed desktop Computers quickly, defines browser readiness, and exposes failures without false Live states.",
      "source": "src/routes/docs/computers/fast-start/+page.md",
      "headings": [
        {
          "title": "Verified result",
          "anchor": "verified-result"
        },
        {
          "title": "What browser-ready means",
          "anchor": "what-browser-ready-means"
        },
        {
          "title": "Application integration",
          "anchor": "application-integration"
        },
        {
          "title": "Troubleshooting",
          "anchor": "troubleshooting"
        },
        {
          "title": "The card says Running but the viewer says Host unavailable",
          "anchor": "the-card-says-running-but-the-viewer-says-host-unavailable"
        },
        {
          "title": "The viewer page returns 503",
          "anchor": "the-viewer-page-returns-503"
        },
        {
          "title": "The stream request returns 409",
          "anchor": "the-stream-request-returns-409"
        },
        {
          "title": "The iframe loads but no desktop appears",
          "anchor": "the-iframe-loads-but-no-desktop-appears"
        },
        {
          "title": "Related documentation",
          "anchor": "related-documentation"
        }
      ],
      "content_excerpt": "# Fast start & readiness\n\nMIOSA Computers use ready capacity on the managed fleet so a new desktop can be assigned without waiting for a full cold boot.\nThe product target is simple: click **Launch**, then receive an interactive desktop in about 800 to 900 ms on the warm path.\n\n## Verified result\n\nThe production canary measured on 2026-08-06 completed **10 of 10** launches and reached a browser-ready desktop in a median **740 ms**.\n\n| Phase | Time |\n|---|---:|\n| Successful launches | `10 / 10` |"
    },
    {
      "slug": "computers/overview",
      "path": "/docs/computers/overview",
      "url": "https://miosa.ai/docs/computers/overview",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/computers/overview",
      "title": "Computers (Desktop)",
      "description": "Durable cloud desktops for browser agents, human takeover, GUI automation, and long-running computer-use workflows.",
      "source": "src/routes/docs/computers/overview/+page.md",
      "headings": [
        {
          "title": "What Computers are for",
          "anchor": "what-computers-are-for"
        },
        {
          "title": "When to use Computer vs Sandbox",
          "anchor": "when-to-use-computer-vs-sandbox"
        },
        {
          "title": "What is in the box",
          "anchor": "what-is-in-the-box"
        },
        {
          "title": "What a Computer is, concretely",
          "anchor": "what-a-computer-is-concretely"
        },
        {
          "title": "Fast startup",
          "anchor": "fast-startup"
        },
        {
          "title": "Access model",
          "anchor": "access-model"
        },
        {
          "title": "Quick example",
          "anchor": "quick-example"
        },
        {
          "title": "Desktop action reference",
          "anchor": "desktop-action-reference"
        },
        {
          "title": "Workspace-scoped creation",
          "anchor": "workspace-scoped-creation"
        },
        {
          "title": "Operator workflow",
          "anchor": "operator-workflow"
        },
        {
          "title": "White-label desktops",
          "anchor": "white-label-desktops"
        },
        {
          "title": "How it fits together",
          "anchor": "how-it-fits-together"
        },
        {
          "title": "Embed the desktop in a browser",
          "anchor": "embed-the-desktop-in-a-browser"
        },
        {
          "title": "Lifecycle",
          "anchor": "lifecycle"
        },
        {
          "title": "Production checklist",
          "anchor": "production-checklist"
        },
        {
          "title": "Sizing",
          "anchor": "sizing"
        },
        {
          "title": "Next",
          "anchor": "next"
        }
      ],
      "content_excerpt": "# Computers\n\nA **Computer** is a durable cloud desktop.\nIt gives each user, agent, or workflow a real Linux GUI with browser state, files, shell access, desktop streaming, and programmatic control.\n\nUse it when the work depends on pixels, sessions, browser logins, desktop apps, accessibility trees, or a human taking over the same machine an agent was using.\nFor pure code execution, builds, and preview servers, [Sandboxes](/docs/develop/sandboxes/) are cheaper and faster.\nFor a 24/7 production we"
    },
    {
      "slug": "concepts",
      "path": "/docs/concepts",
      "url": "https://miosa.ai/docs/concepts",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/concepts",
      "title": "Core Concepts",
      "description": "The canonical MIOSA product model, from mutable sandboxes to immutable releases, stable deployments, persistent data, and customer-owned infrastructure.",
      "source": "src/routes/docs/concepts/+page.md",
      "headings": [
        {
          "title": "The resource hierarchy",
          "anchor": "the-resource-hierarchy"
        },
        {
          "title": "Development resources",
          "anchor": "development-resources"
        },
        {
          "title": "Sandbox",
          "anchor": "sandbox"
        },
        {
          "title": "Preview",
          "anchor": "preview"
        },
        {
          "title": "Production resources",
          "anchor": "production-resources"
        },
        {
          "title": "Builder",
          "anchor": "builder"
        },
        {
          "title": "Release",
          "anchor": "release"
        },
        {
          "title": "Runtime Instance",
          "anchor": "runtime-instance"
        },
        {
          "title": "Domain",
          "anchor": "domain"
        },
        {
          "title": "The immutable publish pipeline",
          "anchor": "the-immutable-publish-pipeline"
        },
        {
          "title": "Persistent bindings and data",
          "anchor": "persistent-bindings-and-data"
        },
        {
          "title": "Computers (desktop product)",
          "anchor": "computers-desktop-product"
        },
        {
          "title": "White-label tenancy",
          "anchor": "white-label-tenancy"
        },
        {
          "title": "External attribution",
          "anchor": "external-attribution"
        },
        {
          "title": "Preview tokens",
          "anchor": "preview-tokens"
        },
        {
          "title": "Share tokens",
          "anchor": "share-tokens"
        },
        {
          "title": "Tenant preview domain",
          "anchor": "tenant-preview-domain"
        },
        {
          "title": "Tenant branding",
          "anchor": "tenant-branding"
        },
        {
          "title": "Three naming layers",
          "anchor": "three-naming-layers"
        },
        {
          "title": "What's next",
          "anchor": "whats-next"
        }
      ],
      "content_excerpt": "# Core Concepts\n\nMIOSA gives developers and agents a safe development loop without making production mutable.\nYou work in a Sandbox, inspect the result through a Preview, and publish a frozen candidate Release.\nAfter MIOSA verifies that candidate, promotion moves the Deployment's stable URL to the new Version.\n\nIf you read only one line, remember this:\n\n**Sandbox (mutable) → Preview → Publish → Release (immutable) → Verify → Promote → Deployment (stable URL).**\n\nThe old Version remains available"
    },
    {
      "slug": "cookbook",
      "path": "/docs/cookbook",
      "url": "https://miosa.ai/docs/cookbook",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/cookbook",
      "title": "Cookbook",
      "description": "End-to-end recipes for app builders, white-label SaaS, lead magnets, code execution, browser agents, previews, and production deploys.",
      "source": "src/routes/docs/cookbook/+page.md",
      "headings": [
        {
          "title": "Agent and app building",
          "anchor": "agent-and-app-building"
        },
        {
          "title": "Multi-tenant and SaaS",
          "anchor": "multi-tenant-and-saas"
        },
        {
          "title": "Embedding and real-time",
          "anchor": "embedding-and-real-time"
        },
        {
          "title": "Resilience and safety",
          "anchor": "resilience-and-safety"
        },
        {
          "title": "Before you start",
          "anchor": "before-you-start"
        }
      ],
      "content_excerpt": "# Cookbook\n\nPractical walkthroughs for the things customers actually build on MIOSA. Each recipe starts with a product goal, then shows the sandbox, preview, deployment, domain, token, and attribution pieces involved.\n\n---\n\n## Agent and app building\n\n  \n    Full lifecycle: user prompt → agent writes files → dev server → live preview → feedback loop → publish → stable production URL.\n  \n  \n    Run code and stream stdout to your UI in real time. Useful for graders, workflow builders, data jobs, an"
    },
    {
      "slug": "cookbook/agent-builds-app",
      "path": "/docs/cookbook/agent-builds-app",
      "url": "https://miosa.ai/docs/cookbook/agent-builds-app",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/cookbook/agent-builds-app",
      "title": "Agent builds an app",
      "description": "Your AI agent receives a prompt, writes code into a sandbox, iterates visually with live preview, checkpoints progress, branches experiments, shares with stakeholders, and publishes to production.",
      "source": "src/routes/docs/cookbook/agent-builds-app/+page.md",
      "headings": [
        {
          "title": "What you'll build",
          "anchor": "what-youll-build"
        },
        {
          "title": "Flow diagram",
          "anchor": "flow-diagram"
        },
        {
          "title": "Prerequisites",
          "anchor": "prerequisites"
        },
        {
          "title": "Step 1: Install and configure",
          "anchor": "step-1-install-and-configure"
        },
        {
          "title": "Step 2: Boot a sandbox and write initial files",
          "anchor": "step-2-boot-a-sandbox-and-write-initial-files"
        },
        {
          "title": "Step 3: Start the dev server and mint a preview token",
          "anchor": "step-3-start-the-dev-server-and-mint-a-preview-token"
        },
        {
          "title": "Step 4: Iterate on feedback",
          "anchor": "step-4-iterate-on-feedback"
        },
        {
          "title": "Watch file changes over SSE",
          "anchor": "watch-file-changes-over-sse"
        },
        {
          "title": "Step 5: Preserve a known-good source",
          "anchor": "step-5-preserve-a-known-good-source"
        },
        {
          "title": "Step 6: Branch into experiments",
          "anchor": "step-6-branch-into-experiments"
        },
        {
          "title": "Step 7: Share with stakeholders",
          "anchor": "step-7-share-with-stakeholders"
        },
        {
          "title": "Step 8: Track usage",
          "anchor": "step-8-track-usage"
        },
        {
          "title": "Step 9: Promote to production",
          "anchor": "step-9-promote-to-production"
        },
        {
          "title": "What you learned",
          "anchor": "what-you-learned"
        },
        {
          "title": "Related",
          "anchor": "related"
        }
      ],
      "content_excerpt": "# Agent builds an app\n\n~15 min Python TypeScript\n\n> **Goal**: Wire an LLM agent to MIOSA so it can write code, boot a live dev server, iterate on feedback with real-time preview, checkpoint progress, branch experiments, share with stakeholders, track usage, and finally publish to production from a single user prompt.\n>\n> **What you'll use**: Sandboxes, Processes, Previews, Snapshots, Shares, Deployments, Usage\n\n## What you'll build\n\nA full-lifecycle function `agent_app_lifecycle(prompt)` that:\n\n"
    },
    {
      "slug": "cookbook/agent-with-secrets",
      "path": "/docs/cookbook/agent-with-secrets",
      "url": "https://miosa.ai/docs/cookbook/agent-with-secrets",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/cookbook/agent-with-secrets",
      "title": "Agent with secrets  -  full walkthrough",
      "description": "Create a sandbox, store an OpenAI key and connect GitHub via OAuth, run an AI agent, watch the audit log live, lock the network down, then rotate the key mid-run.",
      "source": "src/routes/docs/cookbook/agent-with-secrets/+page.md",
      "headings": [
        {
          "title": "What you'll build",
          "anchor": "what-youll-build"
        },
        {
          "title": "Prerequisites",
          "anchor": "prerequisites"
        },
        {
          "title": "Step 1  -  Install and configure",
          "anchor": "step-1-install-and-configure"
        },
        {
          "title": "Step 2  -  Create the sandbox",
          "anchor": "step-2-create-the-sandbox"
        },
        {
          "title": "Step 3  -  Add the OpenAI key to the vault",
          "anchor": "step-3-add-the-openai-key-to-the-vault"
        },
        {
          "title": "Step 4  -  Connect GitHub via OAuth",
          "anchor": "step-4-connect-github-via-oauth"
        },
        {
          "title": "Step 5  -  Write and run the agent",
          "anchor": "step-5-write-and-run-the-agent"
        },
        {
          "title": "Step 6  -  Watch the audit log in real time",
          "anchor": "step-6-watch-the-audit-log-in-real-time"
        },
        {
          "title": "Step 7  -  Lock down the network",
          "anchor": "step-7-lock-down-the-network"
        },
        {
          "title": "Bonus  -  Rotate the OpenAI key while the agent is running",
          "anchor": "bonus-rotate-the-openai-key-while-the-agent-is-running"
        },
        {
          "title": "What you learned",
          "anchor": "what-you-learned"
        },
        {
          "title": "Next",
          "anchor": "next"
        }
      ],
      "content_excerpt": "# Agent with secrets  -  full walkthrough\n\n~20 min Python TypeScript Go\n\n> **Goal**: Build a customer-support AI agent in a MIOSA sandbox that calls OpenAI and reads GitHub issues. Wire up vault-managed secrets for both credentials. Watch the audit trail in real time. Lock down egress to only those two hosts. Then rotate the OpenAI key while the agent is mid-run  -  no restart, no redeploy.\n>\n> **What you'll use**: Sandboxes, Secrets, Connect Accounts, Audit Log, Network Allowlist\n\n## What you'l"
    },
    {
      "slug": "cookbook/browser-agent",
      "path": "/docs/cookbook/browser-agent",
      "url": "https://miosa.ai/docs/cookbook/browser-agent",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/cookbook/browser-agent",
      "title": "Browser agent",
      "description": "Boot a full Linux desktop Computer, screenshot a website, click a button, fill a form, take another screenshot  -  the complete screenshot → action → screenshot loop with your own LLM.",
      "source": "src/routes/docs/cookbook/browser-agent/+page.md",
      "headings": [
        {
          "title": "What you'll build",
          "anchor": "what-youll-build"
        },
        {
          "title": "Prerequisites",
          "anchor": "prerequisites"
        },
        {
          "title": "Step 1  -  Install and configure",
          "anchor": "step-1-install-and-configure"
        },
        {
          "title": "Step 2  -  Boot a Computer",
          "anchor": "step-2-boot-a-computer"
        },
        {
          "title": "Step 3  -  Take a screenshot",
          "anchor": "step-3-take-a-screenshot"
        },
        {
          "title": "Step 4  -  Open a URL in the browser",
          "anchor": "step-4-open-a-url-in-the-browser"
        },
        {
          "title": "Step 5  -  Build the action loop",
          "anchor": "step-5-build-the-action-loop"
        },
        {
          "title": "Step 6  -  Execute actions on the Computer",
          "anchor": "step-6-execute-actions-on-the-computer"
        },
        {
          "title": "Step 7  -  Run the full agent loop",
          "anchor": "step-7-run-the-full-agent-loop"
        },
        {
          "title": "Full script (Python)",
          "anchor": "full-script-python"
        },
        {
          "title": "Tips for reliable browser agents",
          "anchor": "tips-for-reliable-browser-agents"
        },
        {
          "title": "What you learned",
          "anchor": "what-you-learned"
        },
        {
          "title": "Next",
          "anchor": "next"
        }
      ],
      "content_excerpt": "# Browser agent\n\n~12 min Python TypeScript\n\n> **Goal**: Boot a MIOSA Computer (full Linux desktop VM), open a browser inside it, and run an LLM-driven action loop that screenshots the screen, decides what to do next, and executes the action  -  all from your own code.\n>\n> **What you'll use**: Computers, Desktop API (screenshot / click / type / key)\n\n## What you'll build\n\nA `BrowserAgent` class that:\n1. Boots a Computer with a full desktop.\n2. Opens a URL in Chromium.\n3. Enters a screenshot → LLM"
    },
    {
      "slug": "cookbook/build-virtual-device-product",
      "path": "/docs/cookbook/build-virtual-device-product",
      "url": "https://miosa.ai/docs/cookbook/build-virtual-device-product",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/cookbook/build-virtual-device-product",
      "title": "Build a virtual-device product",
      "description": "Build a Nebula-style product on MIOSA with persistent devices, files, browser work, jobs, artifacts, and connected tools.",
      "source": "src/routes/docs/cookbook/build-virtual-device-product/+page.md",
      "headings": [
        {
          "title": "Product promise",
          "anchor": "product-promise"
        },
        {
          "title": "MIOSA mapping",
          "anchor": "miosa-mapping"
        },
        {
          "title": "Architecture",
          "anchor": "architecture"
        },
        {
          "title": "Data model",
          "anchor": "data-model"
        },
        {
          "title": "Device lifecycle",
          "anchor": "device-lifecycle"
        },
        {
          "title": "UI layout",
          "anchor": "ui-layout"
        },
        {
          "title": "CLI shape",
          "anchor": "cli-shape"
        },
        {
          "title": "Jobs and schedules",
          "anchor": "jobs-and-schedules"
        },
        {
          "title": "Connected tools",
          "anchor": "connected-tools"
        },
        {
          "title": "Safety defaults",
          "anchor": "safety-defaults"
        },
        {
          "title": "Build checklist",
          "anchor": "build-checklist"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Build a virtual-device product\n\nA virtual-device product gives users and agents a shared machine that keeps\nstate between conversations. It can hold files, run code, keep browser context,\nexecute jobs, connect to apps, and produce artifacts.\n\nThis is the MIOSA pattern behind Nebula-style devices, always-on operators,\nagent workspaces, browser automation products, and AI company workrooms.\n\n---\n\n## Product promise\n\n```text\n\"Give each workspace a persistent device where agents can work, remember"
    },
    {
      "slug": "cookbook/embed-sandbox-iframe",
      "path": "/docs/cookbook/embed-sandbox-iframe",
      "url": "https://miosa.ai/docs/cookbook/embed-sandbox-iframe",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/cookbook/embed-sandbox-iframe",
      "title": "Embed sandbox in an iframe",
      "description": "Your server mints a preview token; your frontend uses it as an iframe src. Covers React, Vue, Svelte, and vanilla JS, plus token TTL refresh.",
      "source": "src/routes/docs/cookbook/embed-sandbox-iframe/+page.md",
      "headings": [
        {
          "title": "How preview tokens work",
          "anchor": "how-preview-tokens-work"
        },
        {
          "title": "Step 1  -  Server-side: mint the token",
          "anchor": "step-1-server-side-mint-the-token"
        },
        {
          "title": "Step 2  -  Frontend: embed the iframe",
          "anchor": "step-2-frontend-embed-the-iframe"
        },
        {
          "title": "Token refresh strategy",
          "anchor": "token-refresh-strategy"
        },
        {
          "title": "CSP considerations",
          "anchor": "csp-considerations"
        },
        {
          "title": "Related",
          "anchor": "related"
        }
      ],
      "content_excerpt": "# Embed sandbox in an iframe\n\n~8 min Python TypeScript\n\n> **Goal**: Embed a live MIOSA sandbox in your product's UI without exposing your `msk_*` key. Your server mints a short-lived preview token; your frontend drops it into an `<iframe src>`.\n>\n> **What you'll use**: Sandboxes, Preview tokens\n\n## How preview tokens work\n\n```\nBrowser ──── GET /my-api/preview-token ────► Your server\n                                                │\n                                          sbx.previewToken(3600)"
    },
    {
      "slug": "cookbook/lockdown-workflow",
      "path": "/docs/cookbook/lockdown-workflow",
      "url": "https://miosa.ai/docs/cookbook/lockdown-workflow",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/cookbook/lockdown-workflow",
      "title": "Lockdown workflow  -  audit to enforce",
      "description": "Operational playbook for moving a sandbox from audit-only to locked-down network policy. Start safe, review suggestions, lock down, handle pending requests, roll back if needed.",
      "source": "src/routes/docs/cookbook/lockdown-workflow/+page.md",
      "headings": [
        {
          "title": "The four phases",
          "anchor": "the-four-phases"
        },
        {
          "title": "Phase 1  -  Observe",
          "anchor": "phase-1-observe"
        },
        {
          "title": "Phase 2  -  Review suggestions",
          "anchor": "phase-2-review-suggestions"
        },
        {
          "title": "What to keep, what to question",
          "anchor": "what-to-keep-what-to-question"
        },
        {
          "title": "Phase 3  -  Lock down",
          "anchor": "phase-3-lock-down"
        },
        {
          "title": "Verify enforce mode is active",
          "anchor": "verify-enforce-mode-is-active"
        },
        {
          "title": "Test the boundary",
          "anchor": "test-the-boundary"
        },
        {
          "title": "Phase 4  -  Operate",
          "anchor": "phase-4-operate"
        },
        {
          "title": "Handling pending requests",
          "anchor": "handling-pending-requests"
        },
        {
          "title": "Warn-only rules for trial hosts",
          "anchor": "warn-only-rules-for-trial-hosts"
        },
        {
          "title": "Rolling back",
          "anchor": "rolling-back"
        },
        {
          "title": "Exporting the policy for reuse",
          "anchor": "exporting-the-policy-for-reuse"
        },
        {
          "title": "Full script",
          "anchor": "full-script"
        },
        {
          "title": "Troubleshooting",
          "anchor": "troubleshooting"
        },
        {
          "title": "What you learned",
          "anchor": "what-you-learned"
        },
        {
          "title": "Next",
          "anchor": "next"
        }
      ],
      "content_excerpt": "# Lockdown workflow\n\n~10 min Python TypeScript\n\n> **Goal**: Move a sandbox from audit-only (observe everything, block nothing) to enforce mode (block everything not on the allowlist) safely. This playbook walks every step, from \"let it run for a few days\" through \"lock down\" through \"handle something unexpected.\"\n>\n> **What you'll use**: Network Allowlist, Audit Log\n\n## The four phases\n\n```\nPhase 1  -  Observe      sandbox runs, everything logged, nothing blocked\nPhase 2  -  Review       inspect"
    },
    {
      "slug": "cookbook/multi-tenant-saas",
      "path": "/docs/cookbook/multi-tenant-saas",
      "url": "https://miosa.ai/docs/cookbook/multi-tenant-saas",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/cookbook/multi-tenant-saas",
      "title": "Multi-tenant SaaS",
      "description": "Embed MIOSA into your SaaS  -  tag sandboxes per tenant, query usage per workspace, and issue browser tokens so customers interact directly with their sandboxes.",
      "source": "src/routes/docs/cookbook/multi-tenant-saas/+page.md",
      "headings": [
        {
          "title": "What you'll build",
          "anchor": "what-youll-build"
        },
        {
          "title": "Prerequisites",
          "anchor": "prerequisites"
        },
        {
          "title": "Step 1  -  Install and configure",
          "anchor": "step-1-install-and-configure"
        },
        {
          "title": "Step 2  -  Tag every sandbox with your IDs",
          "anchor": "step-2-tag-every-sandbox-with-your-ids"
        },
        {
          "title": "Step 3  -  List sandboxes per tenant",
          "anchor": "step-3-list-sandboxes-per-tenant"
        },
        {
          "title": "Step 4  -  Query usage per tenant",
          "anchor": "step-4-query-usage-per-tenant"
        },
        {
          "title": "Step 5  -  Issue browser tokens for direct access",
          "anchor": "step-5-issue-browser-tokens-for-direct-access"
        },
        {
          "title": "Step 6  -  Full integration wiring",
          "anchor": "step-6-full-integration-wiring"
        },
        {
          "title": "Step 7  -  Set per-user quotas",
          "anchor": "step-7-set-per-user-quotas"
        },
        {
          "title": "Step 8  -  Audit log",
          "anchor": "step-8-audit-log"
        },
        {
          "title": "What you learned",
          "anchor": "what-you-learned"
        },
        {
          "title": "Next",
          "anchor": "next"
        }
      ],
      "content_excerpt": "# Multi-tenant SaaS\n\n~12 min Python TypeScript\n\n> **Goal**: Embed MIOSA into a multi-tenant product. Every sandbox is tagged with your own workspace and user IDs. Usage rolls up per tenant for billing. End-users interact with their sandboxes directly from the browser without ever seeing your API key.\n>\n> **What you'll use**: Sandboxes, External Attribution, Browser Tokens, Usage API\n\n## What you'll build\n\nAn embedded sandbox experience inside your SaaS:\n\n1. Your backend creates sandboxes tagged "
    },
    {
      "slug": "cookbook/per-user-quotas-billing",
      "path": "/docs/cookbook/per-user-quotas-billing",
      "url": "https://miosa.ai/docs/cookbook/per-user-quotas-billing",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/cookbook/per-user-quotas-billing",
      "title": "Per-user quotas and billing",
      "description": "Set per-end-user resource caps, pull monthly usage rollups keyed by external_user_id, and generate invoices for your customers.",
      "source": "src/routes/docs/cookbook/per-user-quotas-billing/+page.md",
      "headings": [
        {
          "title": "Overview",
          "anchor": "overview"
        },
        {
          "title": "Step 1  -  Attribute every sandbox to an end-user",
          "anchor": "step-1-attribute-every-sandbox-to-an-end-user"
        },
        {
          "title": "Step 2  -  Set per-user quotas",
          "anchor": "step-2-set-per-user-quotas"
        },
        {
          "title": "Step 3  -  Check current quota state",
          "anchor": "step-3-check-current-quota-state"
        },
        {
          "title": "Step 4  -  Monthly invoice rollup",
          "anchor": "step-4-monthly-invoice-rollup"
        },
        {
          "title": "Connecting to Stripe (optional)",
          "anchor": "connecting-to-stripe-optional"
        },
        {
          "title": "What you learned",
          "anchor": "what-you-learned"
        },
        {
          "title": "Related",
          "anchor": "related"
        }
      ],
      "content_excerpt": "# Per-user quotas and billing\n\n~10 min Python TypeScript\n\n> **Goal**: Cap each of your end-users so they cannot exhaust your MIOSA allocation, then pull a monthly usage rollup per user to generate accurate invoices.\n>\n> **What you'll use**: Sandboxes (external attribution), Quotas API, Usage API\n\n## Overview\n\nEvery sandbox created with an `external_user_id` is automatically attributed. Two APIs build on top of that:\n\n- **Quotas**  -  hard caps per `external_user_id`: max sandboxes, max concurren"
    },
    {
      "slug": "cookbook/sandbox-events-realtime",
      "path": "/docs/cookbook/sandbox-events-realtime",
      "url": "https://miosa.ai/docs/cookbook/sandbox-events-realtime",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/cookbook/sandbox-events-realtime",
      "title": "Sandbox events in real time",
      "description": "React to sandbox lifecycle events using either HMAC-signed webhooks (server-to-server) or the SSE event stream (in-process). Covers both patterns, idempotency, and when to choose each.",
      "source": "src/routes/docs/cookbook/sandbox-events-realtime/+page.md",
      "headings": [
        {
          "title": "Two patterns  -  choose one",
          "anchor": "two-patterns-choose-one"
        },
        {
          "title": "Pattern A  -  Webhooks",
          "anchor": "pattern-a-webhooks"
        },
        {
          "title": "Register a webhook endpoint",
          "anchor": "register-a-webhook-endpoint"
        },
        {
          "title": "Verify the signature",
          "anchor": "verify-the-signature"
        },
        {
          "title": "Idempotency",
          "anchor": "idempotency"
        },
        {
          "title": "Pattern B  -  SSE event stream",
          "anchor": "pattern-b-sse-event-stream"
        },
        {
          "title": "Filter by event type",
          "anchor": "filter-by-event-type"
        },
        {
          "title": "Event catalog",
          "anchor": "event-catalog"
        },
        {
          "title": "Choosing between patterns",
          "anchor": "choosing-between-patterns"
        },
        {
          "title": "Related",
          "anchor": "related"
        }
      ],
      "content_excerpt": "# Sandbox events in real time\n\n~10 min Python TypeScript\n\n> **Goal**: React to sandbox lifecycle events  -  `sandbox.running`, `sandbox.destroyed`, `deployment.live`, and others  -  using either webhooks (durable, server-to-server) or the SSE stream (ephemeral, in-process).\n>\n> **What you'll use**: Webhooks, Tenant SSE event stream\n\n## Two patterns  -  choose one\n\n| | Webhooks | SSE stream |\n|---|---|---|\n| Delivery | MIOSA calls your URL | Your process pulls |\n| Durability | Retried on failure "
    },
    {
      "slug": "cookbook/snapshot-and-fork",
      "path": "/docs/cookbook/snapshot-and-fork",
      "url": "https://miosa.ai/docs/cookbook/snapshot-and-fork",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/cookbook/snapshot-and-fork",
      "title": "Fork a sandbox safely",
      "description": "Preserve a known-good running sandbox and create independent branches with the canonical public V1 fork operation.",
      "source": "src/routes/docs/cookbook/snapshot-and-fork/+page.md",
      "headings": [
        {
          "title": "Use this pattern",
          "anchor": "use-this-pattern"
        },
        {
          "title": "Create the source",
          "anchor": "create-the-source"
        },
        {
          "title": "Fork an experiment",
          "anchor": "fork-an-experiment"
        },
        {
          "title": "Compare and clean up",
          "anchor": "compare-and-clean-up"
        },
        {
          "title": "Failure recovery",
          "anchor": "failure-recovery"
        }
      ],
      "content_excerpt": "# Fork a sandbox safely\n\nPublic V1 ~5 min\n\nFork creates a new sandbox from a copy-on-write snapshot of a running source sandbox.\nThe source remains unchanged, and the fork receives its own ID, lifecycle, and timeout.\n\n## Use this pattern\n\n```text\nknown-good running source\n  |-- fork -> experiment A -> compare -> destroy or keep\n  |-- fork -> experiment B -> compare -> destroy or keep\n  `-- fork -> recovery retry -> verify\n```\n\nUse forks for parallel agent strategies, risky dependency upgrades, m"
    },
    {
      "slug": "cookbook/streaming-code-execution",
      "path": "/docs/cookbook/streaming-code-execution",
      "url": "https://miosa.ai/docs/cookbook/streaming-code-execution",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/cookbook/streaming-code-execution",
      "title": "Streaming code execution",
      "description": "Run a long Python script in a sandbox and stream stdout to your UI in real time via SSE, with backpressure handling.",
      "source": "src/routes/docs/cookbook/streaming-code-execution/+page.md",
      "headings": [
        {
          "title": "What you'll build",
          "anchor": "what-youll-build"
        },
        {
          "title": "Prerequisites",
          "anchor": "prerequisites"
        },
        {
          "title": "Step 1  -  Install and configure",
          "anchor": "step-1-install-and-configure"
        },
        {
          "title": "Step 2  -  Write a long-running script into the sandbox",
          "anchor": "step-2-write-a-long-running-script-into-the-sandbox"
        },
        {
          "title": "Step 3  -  Stream exec output",
          "anchor": "step-3-stream-exec-output"
        },
        {
          "title": "Step 4  -  Forward the stream to a browser via SSE",
          "anchor": "step-4-forward-the-stream-to-a-browser-via-sse"
        },
        {
          "title": "Step 5  -  Consume in the browser",
          "anchor": "step-5-consume-in-the-browser"
        },
        {
          "title": "Backpressure",
          "anchor": "backpressure"
        },
        {
          "title": "Long-running server processes",
          "anchor": "long-running-server-processes"
        },
        {
          "title": "What you learned",
          "anchor": "what-you-learned"
        },
        {
          "title": "Next",
          "anchor": "next"
        }
      ],
      "content_excerpt": "# Streaming code execution\n\n~8 min Python TypeScript\n\n> **Goal**: Run a long-running script inside a sandbox and stream every stdout line to your frontend UI in real time  -  no polling, no buffering the full output.\n>\n> **What you'll use**: Sandboxes, SSE events, exec streaming\n\n## What you'll build\n\nA minimal code-execution console: your backend creates a sandbox, runs a script, and pipes the sandbox SSE event stream back to the browser. The browser displays each line as it arrives. Looks like"
    },
    {
      "slug": "cookbook/white-label-end-users",
      "path": "/docs/cookbook/white-label-end-users",
      "url": "https://miosa.ai/docs/cookbook/white-label-end-users",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/cookbook/white-label-end-users",
      "title": "White-label end-users  -  secrets, audit, OAuth branding",
      "description": "Stamp external_user_id on sandboxes, scope credentials per end-user, surface per-user audit data in your own dashboard, and brand the OAuth consent flow with your domain.",
      "source": "src/routes/docs/cookbook/white-label-end-users/+page.md",
      "headings": [
        {
          "title": "What you'll build",
          "anchor": "what-youll-build"
        },
        {
          "title": "Prerequisites",
          "anchor": "prerequisites"
        },
        {
          "title": "Step 1  -  Stamp identity at create time",
          "anchor": "step-1-stamp-identity-at-create-time"
        },
        {
          "title": "Step 2  -  Store credentials scoped to the end-user",
          "anchor": "step-2-store-credentials-scoped-to-the-end-user"
        },
        {
          "title": "How the proxy resolves the right credential",
          "anchor": "how-the-proxy-resolves-the-right-credential"
        },
        {
          "title": "Step 3  -  Initiate OAuth on behalf of your end-user",
          "anchor": "step-3-initiate-oauth-on-behalf-of-your-end-user"
        },
        {
          "title": "Step 4  -  Display per-user audit data in your dashboard",
          "anchor": "step-4-display-per-user-audit-data-in-your-dashboard"
        },
        {
          "title": "Step 5  -  Brand the OAuth consent screen",
          "anchor": "step-5-brand-the-oauth-consent-screen"
        },
        {
          "title": "Register your OAuth app on GitHub",
          "anchor": "register-your-oauth-app-on-github"
        },
        {
          "title": "Add the override to your MIOSA tenant",
          "anchor": "add-the-override-to-your-miosa-tenant"
        },
        {
          "title": "Your callback route forwards to MIOSA",
          "anchor": "your-callback-route-forwards-to-miosa"
        },
        {
          "title": "Step 6  -  Disable end-user-scoped credentials (optional)",
          "anchor": "step-6-disable-end-user-scoped-credentials-optional"
        },
        {
          "title": "Troubleshooting",
          "anchor": "troubleshooting"
        },
        {
          "title": "What you learned",
          "anchor": "what-you-learned"
        },
        {
          "title": "Next",
          "anchor": "next"
        }
      ],
      "content_excerpt": "# White-label end-users\n\n~15 min Python TypeScript\n\n> **Goal**: You're building a SaaS product on MIOSA. Your end-users create sandboxes through your UI  -  they don't have MIOSA accounts. This recipe shows you how to stamp identity on every sandbox, store per-user credentials, surface a per-user audit feed in your dashboard, and make the GitHub OAuth consent screen say your brand name instead of \"Authorize MIOSA.\"\n>\n> **What you'll use**: External Attribution, Secrets (external_user scope), Aud"
    },
    {
      "slug": "custom-domains",
      "path": "/docs/custom-domains",
      "url": "https://miosa.ai/docs/custom-domains",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/custom-domains",
      "title": "Custom domains",
      "description": "",
      "source": "src/routes/docs/custom-domains/+page.md",
      "headings": [
        {
          "title": "Domain surfaces",
          "anchor": "domain-surfaces"
        },
        {
          "title": "Setup wizard",
          "anchor": "setup-wizard"
        },
        {
          "title": "Required DNS records",
          "anchor": "required-dns-records"
        },
        {
          "title": "TLS certificates",
          "anchor": "tls-certificates"
        },
        {
          "title": "Propagation time",
          "anchor": "propagation-time"
        },
        {
          "title": "Troubleshooting",
          "anchor": "troubleshooting"
        },
        {
          "title": "Branding",
          "anchor": "branding"
        }
      ],
      "content_excerpt": "# Custom Domains\n\nConnect your own domain - for example `app.cliniciq.com` - so users land on your brand rather than a MIOSA fallback URL.\nThis page is the setup-oriented entry point.\nUse [Deployment Domains](/docs/deploy/domains/) as the canonical reference for URL precedence, exact deployment domains, and production routing behavior.\nMIOSA has separate domain surfaces for sandbox previews, production deployments, computers, and exact resource hostnames.\nUse the URL returned by the API for each"
    },
    {
      "slug": "data/auth",
      "path": "/docs/data/auth",
      "url": "https://miosa.ai/docs/data/auth",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/data/auth",
      "title": "Auth-as-a-Service",
      "description": "Opt-in end-user signup, login, and JWT issuance for a sandbox or deployment.",
      "source": "src/routes/docs/data/auth/+page.md",
      "headings": [
        {
          "title": "Opt-in model",
          "anchor": "opt-in-model"
        },
        {
          "title": "What's offered",
          "anchor": "whats-offered"
        },
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "Configuring email delivery",
          "anchor": "configuring-email-delivery"
        },
        {
          "title": "End users are not MIOSA users",
          "anchor": "end-users-are-not-miosa-users"
        },
        {
          "title": "Per-project isolation",
          "anchor": "per-project-isolation"
        },
        {
          "title": "Row-level security (Postgres pattern)",
          "anchor": "row-level-security-postgres-pattern"
        },
        {
          "title": "Bring your own auth?",
          "anchor": "bring-your-own-auth"
        },
        {
          "title": "Python SDK",
          "anchor": "python-sdk"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Managed end-user auth is live.\nAuth is **opt-in** and disabled by default.\nEnable it for a sandbox or deployment and MIOSA provisions the auth schema in the linked managed database.\nThe runtime receives `AUTH_URL`, `AUTH_JWT_SECRET`, and `AUTH_DATABASE_URL`.\n\n## Opt-in model\n\nAuth is disabled by default.\nA sandbox or deployment has no managed signup surface until you enable it.\nThis prevents accidental exposure of authentication endpoints.\n\n**Enable via API:**\n```bash\ncurl -X POST https://api.mi"
    },
    {
      "slug": "data/email",
      "path": "/docs/data/email",
      "url": "https://miosa.ai/docs/data/email",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/data/email",
      "title": "Transactional Email",
      "description": "Configure MIOSA-managed transactional email for project auth, password reset, email confirmation, and platform notifications.",
      "source": "src/routes/docs/data/email/+page.md",
      "headings": [
        {
          "title": "What email covers",
          "anchor": "what-email-covers"
        },
        {
          "title": "MIOSA-managed auth email",
          "anchor": "miosa-managed-auth-email"
        },
        {
          "title": "Other provider options",
          "anchor": "other-provider-options"
        },
        {
          "title": "Platform mailer and notifications",
          "anchor": "platform-mailer-and-notifications"
        },
        {
          "title": "Verification checklist",
          "anchor": "verification-checklist"
        },
        {
          "title": "White-label and enterprise senders",
          "anchor": "white-label-and-enterprise-senders"
        },
        {
          "title": "App-owned email",
          "anchor": "app-owned-email"
        },
        {
          "title": "Next",
          "anchor": "next"
        }
      ],
      "content_excerpt": "# Transactional Email\n\nMIOSA uses transactional email for platform notifications and for per-project\nend-user auth flows such as password reset and email confirmation.\n\nThis page separates three different email patterns:\n\n| Pattern | Who owns it | Examples |\n|---|---|---|\n| **MIOSA-managed auth email** | MIOSA/operator | Password reset, email confirmation, security notices |\n| **App-owned transactional email** | The generated app/customer | Receipts, booking confirmations, workflow notices |\n| *"
    },
    {
      "slug": "data/fractal",
      "path": "/docs/data/fractal",
      "url": "https://miosa.ai/docs/data/fractal",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/data/fractal",
      "title": "Fractal Computing",
      "description": "Fractal is MIOSA's enterprise data partner pattern for client-wide structured data, high-volume calculations, reconciliation, and private data-plane deployments.",
      "source": "src/routes/docs/data/fractal/+page.md",
      "headings": [
        {
          "title": "The role split",
          "anchor": "the-role-split"
        },
        {
          "title": "Enterprise data model",
          "anchor": "enterprise-data-model"
        },
        {
          "title": "How it compares to built-in primitives",
          "anchor": "how-it-compares-to-built-in-primitives"
        },
        {
          "title": "Enterprise architecture",
          "anchor": "enterprise-architecture"
        },
        {
          "title": "When this is the right pattern",
          "anchor": "when-this-is-the-right-pattern"
        },
        {
          "title": "What the customer sees",
          "anchor": "what-the-customer-sees"
        },
        {
          "title": "Deployment models",
          "anchor": "deployment-models"
        },
        {
          "title": "Engagement path",
          "anchor": "engagement-path"
        },
        {
          "title": "Governed writeback",
          "anchor": "governed-writeback"
        },
        {
          "title": "Connector expectations",
          "anchor": "connector-expectations"
        },
        {
          "title": "Fractal references",
          "anchor": "fractal-references"
        },
        {
          "title": "Common enterprise workflows",
          "anchor": "common-enterprise-workflows"
        },
        {
          "title": "Next",
          "anchor": "next"
        }
      ],
      "content_excerpt": "# Fractal Computing\n\nFractal is MIOSA's enterprise data partner pattern for customers whose data work\nis bigger than an application database: client-wide structured data,\nhigh-volume calculations, reconciliation, and customer-controlled data-plane\ndeployments.\n\nUse MIOSA's built-in databases, storage, Redis, auth, volumes, and Qdrant for\nnormal application state. Bring Fractal into the architecture when the customer\nneeds enterprise-scale data work behind MIOSA apps, agents, sandboxes,\ndeploymen"
    },
    {
      "slug": "data/mysql",
      "path": "/docs/data/mysql",
      "url": "https://miosa.ai/docs/data/mysql",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/data/mysql",
      "title": "MySQL",
      "description": "Managed MySQL per project with durable storage and DATABASE_URL injection.",
      "source": "src/routes/docs/data/mysql/+page.md",
      "headings": [
        {
          "title": "When to use MySQL",
          "anchor": "when-to-use-mysql"
        },
        {
          "title": "Runtime contract",
          "anchor": "runtime-contract"
        },
        {
          "title": "Provisioning pattern",
          "anchor": "provisioning-pattern"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Managed MySQL is available for projects that need MySQL-compatible schemas,\nframeworks, or imports. MIOSA provisions the instance, stores credentials, and\ninjects `DATABASE_URL` into attached sandboxes and production runtimes.\n\n## When to use MySQL\n\nUse managed MySQL when the application already expects MySQL semantics:\n\n- Laravel, WordPress, or MySQL-first frameworks\n- Existing customer schemas that should not be converted to Postgres\n- SQL workloads that rely on MySQL-specific behavior\n- SaaS "
    },
    {
      "slug": "data/overview",
      "path": "/docs/data/overview",
      "url": "https://miosa.ai/docs/data/overview",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/data/overview",
      "title": "Data",
      "description": "Managed databases, object storage, auth, and volumes with explicit lifecycle, credentials, and recovery operations.",
      "source": "src/routes/docs/data/overview/+page.md",
      "headings": [
        {
          "title": "Phase status",
          "anchor": "phase-status"
        },
        {
          "title": "Mental model",
          "anchor": "mental-model"
        },
        {
          "title": "Data persists past your VMs",
          "anchor": "data-persists-past-your-vms"
        },
        {
          "title": "How credentials are injected",
          "anchor": "how-credentials-are-injected"
        },
        {
          "title": "Quick example",
          "anchor": "quick-example"
        },
        {
          "title": "How data services attach",
          "anchor": "how-data-services-attach"
        },
        {
          "title": "How it fits together",
          "anchor": "how-it-fits-together"
        },
        {
          "title": "Managed database lifecycle",
          "anchor": "managed-database-lifecycle"
        },
        {
          "title": "Next",
          "anchor": "next"
        }
      ],
      "content_excerpt": "MIOSA Data services give your sandboxes and production runtime instances access to persistent storage without any external account setup. When you attach a data service to a project, MIOSA provisions the resource and injects its credentials at boot  -  your code reads `process.env.DATABASE_URL` and connects. That is the entire integration.\n\n## Phase status\n\nData services ship incrementally. This table reflects verified platform state:\n\n| Service | Status |\n|---|---|\n| Object Storage | **Availabl"
    },
    {
      "slug": "data/postgres",
      "path": "/docs/data/postgres",
      "url": "https://miosa.ai/docs/data/postgres",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/data/postgres",
      "title": "Postgres",
      "description": "Managed Postgres per project with lifecycle controls, backup, restore, and DATABASE_URL injection.",
      "source": "src/routes/docs/data/postgres/+page.md",
      "headings": [
        {
          "title": "Provision",
          "anchor": "provision"
        },
        {
          "title": "Create it your way — API, CLI, or SDK",
          "anchor": "create-it-your-way-api-cli-or-sdk"
        },
        {
          "title": "Connection management",
          "anchor": "connection-management"
        },
        {
          "title": "Schema management is yours",
          "anchor": "schema-management-is-yours"
        },
        {
          "title": "Backups",
          "anchor": "backups"
        },
        {
          "title": "Lifecycle and recovery",
          "anchor": "lifecycle-and-recovery"
        },
        {
          "title": "Sandboxed development with the same DB",
          "anchor": "sandboxed-development-with-the-same-db"
        },
        {
          "title": "Connecting from a sandbox",
          "anchor": "connecting-from-a-sandbox"
        },
        {
          "title": "Limits",
          "anchor": "limits"
        },
        {
          "title": "Costs",
          "anchor": "costs"
        },
        {
          "title": "Bring your own Postgres?",
          "anchor": "bring-your-own-postgres"
        },
        {
          "title": "Python SDK",
          "anchor": "python-sdk"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Managed Postgres supports dedicated instances, `DATABASE_URL` injection, persistent storage, lifecycle operations, on-demand backup, and restore through the CLI and API.\n\n## Provision\n\nWhen a project is created with `data: { postgres: true }`, MIOSA provisions a logical database in a managed Postgres cluster, generates credentials, and injects them as env vars.\n\nDiagram:\ngraph LR\n    PC[Project create] -->|data.postgres=true| MP[MIOSA provisioner]\n    MP --> PG[(Managed Postgres cluster)]\n    PG"
    },
    {
      "slug": "data/qdrant",
      "path": "/docs/data/qdrant",
      "url": "https://miosa.ai/docs/data/qdrant",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/data/qdrant",
      "title": "Qdrant (Vector Database)",
      "description": "Per-project vector database for semantic search and embedding storage. QDRANT_URL injected at boot.",
      "source": "src/routes/docs/data/qdrant/+page.md",
      "headings": [
        {
          "title": "When to use Qdrant",
          "anchor": "when-to-use-qdrant"
        },
        {
          "title": "What you get",
          "anchor": "what-you-get"
        },
        {
          "title": "Provision",
          "anchor": "provision"
        },
        {
          "title": "Data persists past VM destroy",
          "anchor": "data-persists-past-vm-destroy"
        },
        {
          "title": "Typical pattern: RAG pipeline",
          "anchor": "typical-pattern-rag-pipeline"
        },
        {
          "title": "Limits",
          "anchor": "limits"
        },
        {
          "title": "Bring your own Qdrant?",
          "anchor": "bring-your-own-qdrant"
        },
        {
          "title": "Python SDK",
          "anchor": "python-sdk"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Managed Qdrant is live. Per-project dedicated instances, QDRANT_URL injection at boot, and data persistence across VM destroy are all working.\n\n## When to use Qdrant\n\nUse Qdrant when an agent or app needs durable semantic memory:\n\n- Retrieval-augmented generation (RAG)\n- Document and knowledge-base search\n- Product or lead similarity matching\n- Long-running agent memory across sessions\n- Embeddings produced inside sandboxes or computers\n\nUse object storage for the raw files and Qdrant for the ve"
    },
    {
      "slug": "data/redis",
      "path": "/docs/data/redis",
      "url": "https://miosa.ai/docs/data/redis",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/data/redis",
      "title": "Redis / Cache",
      "description": "Managed Redis per project for caching, sessions, and pub/sub.",
      "source": "src/routes/docs/data/redis/+page.md",
      "headings": [
        {
          "title": "What you get",
          "anchor": "what-you-get"
        },
        {
          "title": "Use cases",
          "anchor": "use-cases"
        },
        {
          "title": "Provision",
          "anchor": "provision"
        },
        {
          "title": "Limits and durability",
          "anchor": "limits-and-durability"
        },
        {
          "title": "Pub/sub considerations",
          "anchor": "pubsub-considerations"
        },
        {
          "title": "Bring your own Redis?",
          "anchor": "bring-your-own-redis"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Managed Redis is live.\nPer-project instances and `REDIS_URL` injection are available.\nRedis is provisioned or attached explicitly and should not be assumed to exist in every sandbox template.\n\n## What you get\n\nPer project: a managed Redis instance, with credentials injected as `REDIS_URL`:\n```\n\nREDIS_URL=redis://default:pass@host:port/0\n```\n\nStandard Redis clients work without modification:\n```typescript\n\nconst redis = createClient({ url: process.env.REDIS_URL })\nawait redis.connect()\n\nawait red"
    },
    {
      "slug": "data/storage",
      "path": "/docs/data/storage",
      "url": "https://miosa.ai/docs/data/storage",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/data/storage",
      "title": "Storage / Buckets",
      "description": "Per-project object storage with signed-URL uploads and downloads.",
      "source": "src/routes/docs/data/storage/+page.md",
      "headings": [
        {
          "title": "What you get",
          "anchor": "what-you-get"
        },
        {
          "title": "Use it your way — API, CLI, or SDK",
          "anchor": "use-it-your-way-api-cli-or-sdk"
        },
        {
          "title": "Signed URLs for browser uploads",
          "anchor": "signed-urls-for-browser-uploads"
        },
        {
          "title": "Public vs private",
          "anchor": "public-vs-private"
        },
        {
          "title": "Bandwidth and storage costs",
          "anchor": "bandwidth-and-storage-costs"
        },
        {
          "title": "Limits",
          "anchor": "limits"
        },
        {
          "title": "Sandboxes can use the bucket too",
          "anchor": "sandboxes-can-use-the-bucket-too"
        },
        {
          "title": "Bring your own bucket?",
          "anchor": "bring-your-own-bucket"
        },
        {
          "title": "Python SDK",
          "anchor": "python-sdk"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Object storage is shipped. Buckets, objects, presigned URL (upload and download), quota enforcement, and per-tenant isolation are all live. Large direct uploads (&gt;5 MB) should use the presigned path; see the limits table below.\n\n## What you get\n\nPer project: an S3-compatible bucket, accessed through MIOSA endpoints. Credentials injected as env vars:\n```\n\nSTORAGE_BUCKET=miosa-proj_xxx-uploads\nSTORAGE_ENDPOINT=https://storage.miosa.app\nSTORAGE_KEY_ID=...\nSTORAGE_KEY_SECRET=...\n```\n\nYour code us"
    },
    {
      "slug": "data/volumes",
      "path": "/docs/data/volumes",
      "url": "https://miosa.ai/docs/data/volumes",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/data/volumes",
      "title": "Volumes",
      "description": "Persistent block storage attached to a runtime instance. State that doesn't fit in Postgres.",
      "source": "src/routes/docs/data/volumes/+page.md",
      "headings": [
        {
          "title": "Create",
          "anchor": "create"
        },
        {
          "title": "Use it your way — API, CLI, or SDK",
          "anchor": "use-it-your-way-api-cli-or-sdk"
        },
        {
          "title": "Mount",
          "anchor": "mount"
        },
        {
          "title": "Replicas and volumes",
          "anchor": "replicas-and-volumes"
        },
        {
          "title": "Limits",
          "anchor": "limits"
        },
        {
          "title": "When to use a volume",
          "anchor": "when-to-use-a-volume"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Volumes are live.\nCreate a persistent block device, attach it to a compatible computer on the same host, and preserve writes independently of the computer lifecycle.\nAttachment to a replacement computer is explicit.\nMost workloads should use [Postgres](/docs/data/postgres/) or [Storage](/docs/data/storage/) because local volumes are host-bound.\n\nA **Volume** is a persistent block device attached to a compatible computer.\nIt survives ordinary computer restarts while the host-local volume remains "
    },
    {
      "slug": "deploy/docker-deploy",
      "path": "/docs/deploy/docker-deploy",
      "url": "https://miosa.ai/docs/deploy/docker-deploy",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/deploy/docker-deploy",
      "title": "App Engine",
      "description": "Run many customer deployments on one always-on workspace App Engine host while MIOSA keeps routing, domains, and attribution as the source of truth.",
      "source": "src/routes/docs/deploy/docker-deploy/+page.md",
      "headings": [
        {
          "title": "How it works",
          "anchor": "how-it-works"
        },
        {
          "title": "Host lifecycle",
          "anchor": "host-lifecycle"
        },
        {
          "title": "Default URL behavior",
          "anchor": "default-url-behavior"
        },
        {
          "title": "Workspace and project scoping",
          "anchor": "workspace-and-project-scoping"
        },
        {
          "title": "Publishing to App Engine",
          "anchor": "publishing-to-app-engine"
        },
        {
          "title": "Proving App Engine deployments",
          "anchor": "proving-app-engine-deployments"
        },
        {
          "title": "Updates and recovery",
          "anchor": "updates-and-recovery"
        },
        {
          "title": "Starter templates",
          "anchor": "starter-templates"
        },
        {
          "title": "Runtime boundary",
          "anchor": "runtime-boundary"
        },
        {
          "title": "Domains",
          "anchor": "domains"
        },
        {
          "title": "What users see",
          "anchor": "what-users-see"
        },
        {
          "title": "API and SDKs",
          "anchor": "api-and-sdks"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# App Engine\n\nApp Engine is MIOSA's dedicated workspace host model for customers that need many small apps, funnels, lead magnets, APIs, or client sites without creating a new production VM for every deployment.\nIt is the recommended production path for generated apps that should run 24/7 inside a workspace.\n\n## How it works\n\nDiagram:\nflowchart LR\n    SB[Sandbox] --> REL[MIOSA release artifact]\n    REL --> IMG[Docker image]\n    IMG --> HOST[Workspace App Engine host]\n    HOST --> APP1[Local app "
    },
    {
      "slug": "deploy/domains",
      "path": "/docs/deploy/domains",
      "url": "https://miosa.ai/docs/deploy/domains",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/deploy/domains",
      "title": "Deployment Domains",
      "description": "Preview domains, tenant deployment domains, managed fallback URLs, exact custom domains, DNS verification, automatic TLS, and route changes.",
      "source": "src/routes/docs/deploy/domains/+page.md",
      "headings": [
        {
          "title": "Domain layers",
          "anchor": "domain-layers"
        },
        {
          "title": "Tenant deployment domains",
          "anchor": "tenant-deployment-domains"
        },
        {
          "title": "Exact custom domains",
          "anchor": "exact-custom-domains"
        },
        {
          "title": "The attach flow",
          "anchor": "the-attach-flow"
        },
        {
          "title": "Redirect policy",
          "anchor": "redirect-policy"
        },
        {
          "title": "What changing a domain does",
          "anchor": "what-changing-a-domain-does"
        },
        {
          "title": "DNS verification edge cases",
          "anchor": "dns-verification-edge-cases"
        },
        {
          "title": "Provider input fields",
          "anchor": "provider-input-fields"
        },
        {
          "title": "Verification sequence",
          "anchor": "verification-sequence"
        },
        {
          "title": "White-label checklist",
          "anchor": "white-label-checklist"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "A **Domain** is a hostname that routes to a preview, a deployment, a computer, or an exact custom resource. For production deployments, always use the `public_url` returned by the API. Do not reconstruct hostnames in SDKs, CLIs, or frontends.\n\n## Domain layers\n\nMIOSA keeps these layers separate:\n\n| Layer | URL shape | Purpose |\n|---|---|---|\n| Sandbox preview domain | `https://{port}-{sandbox_slug}.sandbox.{preview_domain}` | Mutable live previews while an agent/user is editing |\n| Tenant deploy"
    },
    {
      "slug": "deploy/environments",
      "path": "/docs/deploy/environments",
      "url": "https://miosa.ai/docs/deploy/environments",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/deploy/environments",
      "title": "Environments",
      "description": "Production, staging, preview/<source> — variable and secret scoping for deployments.",
      "source": "src/routes/docs/deploy/environments/+page.md",
      "headings": [
        {
          "title": "Defaults",
          "anchor": "defaults"
        },
        {
          "title": "What environments scope",
          "anchor": "what-environments-scope"
        },
        {
          "title": "Env vars",
          "anchor": "env-vars"
        },
        {
          "title": "Secrets vs env vars",
          "anchor": "secrets-vs-env-vars"
        },
        {
          "title": "Data service bindings",
          "anchor": "data-service-bindings"
        },
        {
          "title": "Where to go next",
          "anchor": "where-to-go-next"
        }
      ],
      "content_excerpt": "A **Deployment Environment** is the scope at which env vars, secrets, and data service bindings apply. Most projects have at least two: `production` and `staging`. Custom environments like `preview/feature-abc` are common for review-app workflows.\n\nFirst-class `deployment_environments` records are part of the ongoing deployment refactor. Today, env vars are scoped per-deployment via `deployment_env_vars`. The shape and behavior here are the steady-state target.\n\n## Defaults\n\nEvery project gets t"
    },
    {
      "slug": "deploy/overview",
      "path": "/docs/deploy/overview",
      "url": "https://miosa.ai/docs/deploy/overview",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/deploy/overview",
      "title": "Deploy",
      "description": "Turn a sandbox into a stable production URL with immutable versions, health checks, App Engine, deployment domains, custom domains, proof, and rollback.",
      "source": "src/routes/docs/deploy/overview/+page.md",
      "headings": [
        {
          "title": "The deployment pipeline",
          "anchor": "the-deployment-pipeline"
        },
        {
          "title": "Static vs Dynamic",
          "anchor": "static-vs-dynamic"
        },
        {
          "title": "The deployment object",
          "anchor": "the-deployment-object"
        },
        {
          "title": "What gets versioned",
          "anchor": "what-gets-versioned"
        },
        {
          "title": "Proof contract",
          "anchor": "proof-contract"
        },
        {
          "title": "Next",
          "anchor": "next"
        }
      ],
      "content_excerpt": "Deploying on MIOSA means turning a Sandbox into a stable production app, site, or API backed by immutable versions, health checks, and a public URL returned by the API.\nOnce published, the deployment URL stays stable.\nNew publishes change which version it points at.\n\n## The deployment pipeline\n\nEvery publish travels the same path:\nDiagram:\ngraph LR\n    A[Sandbox] -->|publish| B[Source Snapshot]\n    B --> C[Build]\n    C -->|builds| D[Release]\n    D -->|creates| E[Deployment Version]\n    E -->|pro"
    },
    {
      "slug": "deploy/publishing",
      "path": "/docs/deploy/publishing",
      "url": "https://miosa.ai/docs/deploy/publishing",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/deploy/publishing",
      "title": "Publishing",
      "description": "Turn a Sandbox into an immutable Deployment Version. Source snapshots, build modes, static artifacts, dynamic runtimes, App Engine containers, public URLs, and proof.",
      "source": "src/routes/docs/deploy/publishing/+page.md",
      "headings": [
        {
          "title": "The pipeline",
          "anchor": "the-pipeline"
        },
        {
          "title": "The publish call",
          "anchor": "the-publish-call"
        },
        {
          "title": "Source snapshots",
          "anchor": "source-snapshots"
        },
        {
          "title": "Build modes",
          "anchor": "build-modes"
        },
        {
          "title": "App Engine publish",
          "anchor": "app-engine-publish"
        },
        {
          "title": "What gets promoted, and when",
          "anchor": "what-gets-promoted-and-when"
        },
        {
          "title": "Idempotency",
          "anchor": "idempotency"
        },
        {
          "title": "Failure modes",
          "anchor": "failure-modes"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Publish is the moment a mutable sandbox becomes a frozen, reproducible artifact ready to serve production traffic.\nThe final runtime can be standard MIOSA Deploy or App Engine.\nThe public URL always comes from MIOSA.\n\n## The pipeline\nDiagram:\nflowchart LR\n    SB[Sandbox] -->|freeze /workspace| SS[Source Snapshot]\n    SS --> BLD[Build]\n    BLD -->|compile + package| REL[Release]\n    REL -->|referenced by| VER[Deployment Version]\n    VER -->|promote| DEP[Deployment]\n    DEP -->|standard deploy or "
    },
    {
      "slug": "deploy/releases",
      "path": "/docs/deploy/releases",
      "url": "https://miosa.ai/docs/deploy/releases",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/deploy/releases",
      "title": "Releases",
      "description": "The immutable build artifact — static files or dynamic server artifact, sha256-keyed.",
      "source": "src/routes/docs/deploy/releases/+page.md",
      "headings": [
        {
          "title": "Release kinds",
          "anchor": "release-kinds"
        },
        {
          "title": "Immutability",
          "anchor": "immutability"
        },
        {
          "title": "Where releases live",
          "anchor": "where-releases-live"
        },
        {
          "title": "Source snapshot vs release",
          "anchor": "source-snapshot-vs-release"
        },
        {
          "title": "Garbage collection",
          "anchor": "garbage-collection"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "A **Release** is the immutable artifact produced by a build. Versions reference releases; static deployments serve files from them and dynamic deployments start runtimes from them.\n\nYou typically don't address releases directly through the API — they're an implementation detail of `Deployment Version`. But it's useful to know they exist as their own record because they're what makes rollback and horizontal scaling work.\n\nMost integrations do not need to read release records directly. Use deploym"
    },
    {
      "slug": "deploy/rollback",
      "path": "/docs/deploy/rollback",
      "url": "https://miosa.ai/docs/deploy/rollback",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/deploy/rollback",
      "title": "Rollback",
      "description": "Repoint a deployment at an older version. Seconds, no rebuild.",
      "source": "src/routes/docs/deploy/rollback/+page.md",
      "headings": [
        {
          "title": "When you'd rollback",
          "anchor": "when-youd-rollback"
        },
        {
          "title": "How fast",
          "anchor": "how-fast"
        },
        {
          "title": "How rollback works",
          "anchor": "how-rollback-works"
        },
        {
          "title": "API",
          "anchor": "api"
        },
        {
          "title": "Picking the rollback target",
          "anchor": "picking-the-rollback-target"
        },
        {
          "title": "Rolling forward after rollback",
          "anchor": "rolling-forward-after-rollback"
        },
        {
          "title": "What rollback doesn't fix",
          "anchor": "what-rollback-doesnt-fix"
        },
        {
          "title": "Idempotency",
          "anchor": "idempotency"
        },
        {
          "title": "Audit",
          "anchor": "audit"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Rollback on MIOSA is fast because nothing has to be rebuilt. The previous release is still in storage. Runtime instances boot quickly. Static artifacts are streamed from object storage. The whole operation is \"change one row, propagate to the edge cache.\"\n\n## When you'd rollback\n\n- New version passed health checks but the app is broken in real traffic (e.g. a feature flag mis-fire).\n- A bad migration deployed.\n- A regression you missed in staging.\n- Hostile incident — quick revert while you inve"
    },
    {
      "slug": "deploy/runtime-instances",
      "path": "/docs/deploy/runtime-instances",
      "url": "https://miosa.ai/docs/deploy/runtime-instances",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/deploy/runtime-instances",
      "title": "Dynamic Runtimes",
      "description": "Dynamic deployments — production runtimes started from a release, health-checked, and reconciled by MIOSA.",
      "source": "src/routes/docs/deploy/runtime-instances/+page.md",
      "headings": [
        {
          "title": "What a runtime instance is",
          "anchor": "what-a-runtime-instance-is"
        },
        {
          "title": "What you control vs what MIOSA controls",
          "anchor": "what-you-control-vs-what-miosa-controls"
        },
        {
          "title": "Lifecycle",
          "anchor": "lifecycle"
        },
        {
          "title": "Health checks and the grace period",
          "anchor": "health-checks-and-the-grace-period"
        },
        {
          "title": "Blue/green during publish",
          "anchor": "bluegreen-during-publish"
        },
        {
          "title": "Replicas",
          "anchor": "replicas"
        },
        {
          "title": "Resource sizing",
          "anchor": "resource-sizing"
        },
        {
          "title": "Logs",
          "anchor": "logs"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "A **Runtime Instance** is a running production runtime that serves a dynamic deployment. Static deployments do not have runtime instances; they are served from immutable static artifacts.\n\nThe caller-facing contract is stable: dynamic deployments start production runtimes, wait for health checks, and only promote when the new version is ready. You do not need to know how MIOSA places or reconciles those runtimes.\n\n## What a runtime instance is\n\nA runtime started from the customer's release. The "
    },
    {
      "slug": "deploy/versions",
      "path": "/docs/deploy/versions",
      "url": "https://miosa.ai/docs/deploy/versions",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/deploy/versions",
      "title": "Versions",
      "description": "Immutable history of every publish. Inspect, promote, archive.",
      "source": "src/routes/docs/deploy/versions/+page.md",
      "headings": [
        {
          "title": "Version shape",
          "anchor": "version-shape"
        },
        {
          "title": "States",
          "anchor": "states"
        },
        {
          "title": "Endpoints",
          "anchor": "endpoints"
        },
        {
          "title": "List versions",
          "anchor": "list-versions"
        },
        {
          "title": "Promote a specific version",
          "anchor": "promote-a-specific-version"
        },
        {
          "title": "Versions and external attribution",
          "anchor": "versions-and-external-attribution"
        },
        {
          "title": "How long are versions kept?",
          "anchor": "how-long-are-versions-kept"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Each successful publish produces a **Deployment Version**. Versions are immutable — the source hash, artifact hash, build log, and runtime config are frozen at creation. Versions never change after they're written.\n\nHow Deployments, Versions, and Releases relate:\n\nDiagram:\ngraph TB\n    DEP[Deployment smile-dental] -->|active_version_id| V3[Version v3 - active]\n    DEP -->|history| V2[Version v2 - archived]\n    DEP -->|history| V1[Version v1 - archived]\n    V3 -->|artifact_uri| R3[Release sha256:"
    },
    {
      "slug": "develop/aws-byoc",
      "path": "/docs/develop/aws-byoc",
      "url": "https://miosa.ai/docs/develop/aws-byoc",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/develop/aws-byoc",
      "title": "Managed and AWS BYOC sandboxes",
      "description": "Understand the host, trust, artifact, acceptance, and responsibility boundaries for MIOSA-managed and customer-owned sandbox capacity.",
      "source": "src/routes/docs/develop/aws-byoc/+page.md",
      "headings": [
        {
          "title": "Runtime boundary",
          "anchor": "runtime-boundary"
        },
        {
          "title": "Certified artifacts",
          "anchor": "certified-artifacts"
        },
        {
          "title": "Host acceptance before placement",
          "anchor": "host-acceptance-before-placement"
        },
        {
          "title": "Configuration vs request parameters",
          "anchor": "configuration-vs-request-parameters"
        },
        {
          "title": "Responsibility boundary",
          "anchor": "responsibility-boundary"
        },
        {
          "title": "Availability and limits",
          "anchor": "availability-and-limits"
        }
      ],
      "content_excerpt": "# Managed and AWS BYOC sandboxes\n\nMIOSA-managed sandboxes run on capacity operated by MIOSA.\nAWS BYOC places eligible sandboxes on accepted hosts in a customer's AWS environment while retaining the public sandbox API and resource contract.\n\nAWS BYOC sandbox capacity is a gated private preview.\nCatalog entries and API access do not prove that a customer host has passed acceptance or that placement is enabled.\n\n## Runtime boundary\n\nEach customer host runs the standalone `miosa_host` runtime.\nCusto"
    },
    {
      "slug": "develop/files-and-exec",
      "path": "/docs/develop/files-and-exec",
      "url": "https://miosa.ai/docs/develop/files-and-exec",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/develop/files-and-exec",
      "title": "Files & Exec",
      "description": "Read, write, watch files inside a sandbox. Run commands, stream stdout/stderr, manage processes.",
      "source": "src/routes/docs/develop/files-and-exec/+page.md",
      "headings": [
        {
          "title": "Files",
          "anchor": "files"
        },
        {
          "title": "Write",
          "anchor": "write"
        },
        {
          "title": "Read",
          "anchor": "read"
        },
        {
          "title": "Export generated artifacts",
          "anchor": "export-generated-artifacts"
        },
        {
          "title": "List",
          "anchor": "list"
        },
        {
          "title": "Watch",
          "anchor": "watch"
        },
        {
          "title": "Filesystem layout",
          "anchor": "filesystem-layout"
        },
        {
          "title": "Exec",
          "anchor": "exec"
        },
        {
          "title": "One-shot",
          "anchor": "one-shot"
        },
        {
          "title": "Detached (long-running servers)",
          "anchor": "detached-long-running-servers"
        },
        {
          "title": "Streaming",
          "anchor": "streaming"
        },
        {
          "title": "Terminal",
          "anchor": "terminal"
        },
        {
          "title": "Process management",
          "anchor": "process-management"
        },
        {
          "title": "Idempotency",
          "anchor": "idempotency"
        },
        {
          "title": "Limits",
          "anchor": "limits"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Files & Exec\n\nThe Files and Exec APIs are how you (or an AI agent) interact with a Sandbox. Together they're the substrate for everything else: generating code, running builds, starting servers.\n\n## Files\n\n### Write\n\n```typescript\nawait sandbox.files.write(\"/workspace/src/index.ts\", `\n  console.log(\"Hello from MIOSA\")\n`)\n\n// Binary\nawait sandbox.files.write(\"/workspace/logo.png\", pngBuffer, {\n  encoding: \"binary\",\n})\n```\n\n```bash\ncurl -X POST https://api.miosa.ai/api/v1/sandboxes/$SBX/files/wr"
    },
    {
      "slug": "develop/previews",
      "path": "/docs/develop/previews",
      "url": "https://miosa.ai/docs/develop/previews",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/develop/previews",
      "title": "Previews",
      "description": "Live URLs that proxy into a sandbox port. Public, private, embeddable, share-tokenized.",
      "source": "src/routes/docs/develop/previews/+page.md",
      "headings": [
        {
          "title": "Quick create",
          "anchor": "quick-create"
        },
        {
          "title": "Visibility",
          "anchor": "visibility"
        },
        {
          "title": "Share tokens",
          "anchor": "share-tokens"
        },
        {
          "title": "Iframe embedding",
          "anchor": "iframe-embedding"
        },
        {
          "title": "How it works",
          "anchor": "how-it-works"
        },
        {
          "title": "Lifecycle",
          "anchor": "lifecycle"
        },
        {
          "title": "Preview vs Deployment URL",
          "anchor": "preview-vs-deployment-url"
        },
        {
          "title": "Abuse limits",
          "anchor": "abuse-limits"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Previews\n\nA **Preview** is a URL that routes to a port inside a running Sandbox. The agent writes code, starts a dev server, the preview updates live in the browser. This is the build loop of AI app builders.\n\n## Quick create\n\n```typescript\n// Make sure something is listening on the port first\nconst preview = await sandbox.previews.create({\n  port: 3000,\n  visibility: \"private\",   // or \"public\"\n})\n\nconsole.log(preview.url)\n// → https://3000-abc12345.sandbox.miosa.ai\n```\n\n```bash\ncurl -X POST "
    },
    {
      "slug": "develop/sandboxes",
      "path": "/docs/develop/sandboxes",
      "url": "https://miosa.ai/docs/develop/sandboxes",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/develop/sandboxes",
      "title": "Sandboxes",
      "description": "Mutable isolated environments for AI agent code execution. Run commands, edit files, expose ports as live preview URLs, snapshot state, and publish to production.",
      "source": "src/routes/docs/develop/sandboxes/+page.md",
      "headings": [
        {
          "title": "What Sandboxes are for",
          "anchor": "what-sandboxes-are-for"
        },
        {
          "title": "What a Sandbox is, concretely",
          "anchor": "what-a-sandbox-is-concretely"
        },
        {
          "title": "Configuration vs per-sandbox parameters",
          "anchor": "configuration-vs-per-sandbox-parameters"
        },
        {
          "title": "Sandbox vs Computer vs App Engine",
          "anchor": "sandbox-vs-computer-vs-app-engine"
        },
        {
          "title": "Core capabilities",
          "anchor": "core-capabilities"
        },
        {
          "title": "Lifecycle",
          "anchor": "lifecycle"
        },
        {
          "title": "Fast path: create and run",
          "anchor": "fast-path-create-and-run"
        },
        {
          "title": "Create with full options",
          "anchor": "create-with-full-options"
        },
        {
          "title": "Context manager (auto-destroy)",
          "anchor": "context-manager-auto-destroy"
        },
        {
          "title": "Connect to an existing sandbox",
          "anchor": "connect-to-an-existing-sandbox"
        },
        {
          "title": "Run a command: exec",
          "anchor": "run-a-command-exec"
        },
        {
          "title": "Stream stdout/stderr in real time",
          "anchor": "stream-stdoutstderr-in-real-time"
        },
        {
          "title": "Files: write, read, list, stat",
          "anchor": "files-write-read-list-stat"
        },
        {
          "title": "Filesystem layout",
          "anchor": "filesystem-layout"
        },
        {
          "title": "Previews: expose a port",
          "anchor": "previews-expose-a-port"
        },
        {
          "title": "Snapshots and forks",
          "anchor": "snapshots-and-forks"
        },
        {
          "title": "Pause and resume",
          "anchor": "pause-and-resume"
        },
        {
          "title": "Environment variables",
          "anchor": "environment-variables"
        },
        {
          "title": "Subscribe to sandbox events",
          "anchor": "subscribe-to-sandbox-events"
        },
        {
          "title": "List and filter sandboxes",
          "anchor": "list-and-filter-sandboxes"
        },
        {
          "title": "Timeout and usage",
          "anchor": "timeout-and-usage"
        },
        {
          "title": "Sizing reference",
          "anchor": "sizing-reference"
        },
        {
          "title": "Custom templates",
          "anchor": "custom-templates"
        },
        {
          "title": "Production checklist",
          "anchor": "production-checklist"
        },
        {
          "title": "Billing notes",
          "anchor": "billing-notes"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Sandboxes\n\nA **Sandbox** is MIOSA's fast code execution environment.\nYour agent writes files into it, executes commands, exposes ports as live preview URLs, and snapshots state for branching or rollback.\nUse it for build loops, tests, scripts, package installs, code generation, preview servers, and short-lived automation.\n\nSandboxes are persistent by default.\nWhen you pause them or their timeout expires, MIOSA preserves the filesystem and moves the session to `paused` so it can resume later.\nD"
    },
    {
      "slug": "develop/snapshots",
      "path": "/docs/develop/snapshots",
      "url": "https://miosa.ai/docs/develop/snapshots",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/develop/snapshots",
      "title": "Snapshots, restore, pause, and forks",
      "description": "Create durable sandbox checkpoints, restore or fork new sandboxes, and preserve work through pause and resume.",
      "source": "src/routes/docs/develop/snapshots/+page.md",
      "headings": [
        {
          "title": "Sandbox state lifecycle",
          "anchor": "sandbox-state-lifecycle"
        },
        {
          "title": "Snapshots, restore, and fork",
          "anchor": "snapshots-restore-and-fork"
        },
        {
          "title": "Snapshot statuses",
          "anchor": "snapshot-statuses"
        },
        {
          "title": "Pause and resume",
          "anchor": "pause-and-resume"
        },
        {
          "title": "Timeout and persistence",
          "anchor": "timeout-and-persistence"
        },
        {
          "title": "Fork from a snapshot",
          "anchor": "fork-from-a-snapshot"
        },
        {
          "title": "Managed and BYOC behavior",
          "anchor": "managed-and-byoc-behavior"
        }
      ],
      "content_excerpt": "# Snapshots, restore, pause, and forks\n\nMIOSA sandboxes are persistent by default.\nThe sandbox record and workspace outlive an individual running session until the sandbox is destroyed.\n\n## Sandbox state lifecycle\n\nThe sandbox record has five public states.\nSnapshots and forks are separate resources and operations, not additional sandbox states.\n\nDiagram:\nflowchart TB\n    create([Create]) --> provisioning[provisioning]\n    provisioning -->|runtime ready| running[running]\n    running -->|pause or"
    },
    {
      "slug": "develop/templates",
      "path": "/docs/develop/templates",
      "url": "https://miosa.ai/docs/develop/templates",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/develop/templates",
      "title": "Templates",
      "description": "Pre-built template images for every major language and framework. Pick the closest match to your stack.",
      "source": "src/routes/docs/develop/templates/+page.md",
      "headings": [
        {
          "title": "Template catalog",
          "anchor": "template-catalog"
        },
        {
          "title": "miosa-sandbox",
          "anchor": "miosa-sandbox"
        },
        {
          "title": "node",
          "anchor": "node"
        },
        {
          "title": "nextjs",
          "anchor": "nextjs"
        },
        {
          "title": "react-vite",
          "anchor": "react-vite"
        },
        {
          "title": "svelte",
          "anchor": "svelte"
        },
        {
          "title": "python",
          "anchor": "python"
        },
        {
          "title": "go",
          "anchor": "go"
        },
        {
          "title": "rust",
          "anchor": "rust"
        },
        {
          "title": "static",
          "anchor": "static"
        },
        {
          "title": "Custom templates",
          "anchor": "custom-templates"
        },
        {
          "title": "BuildSpec primer",
          "anchor": "buildspec-primer"
        }
      ],
      "content_excerpt": "# Templates\n\nA **template** is a pre-built template image with a specific language and framework already installed. Pick the closest match to your stack; you can override install/start commands per-sandbox if needed.\n\n## Template catalog\n\n| Slug | Language / Framework | Default port | Best for |\n|---|---|---|---|\n| [`miosa-sandbox`](#miosa-sandbox) | Generic (default) |  -  | Custom builds, scripting, any language |\n| [`node`](#node) | Node.js 24 LTS | 3000 | Node servers, scripts, CLIs |\n| [`ne"
    },
    {
      "slug": "evaluations",
      "path": "/docs/evaluations",
      "url": "https://miosa.ai/docs/evaluations",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/evaluations",
      "title": "Evaluations",
      "description": "Measure sandbox, desktop, and agent workflows with reproducible tasks, traces, and desktop-readiness benchmarks.",
      "source": "src/routes/docs/evaluations/+page.md",
      "headings": [
        {
          "title": "Why evaluations matter",
          "anchor": "why-evaluations-matter"
        },
        {
          "title": "OSWorld-compatible benchmark direction",
          "anchor": "osworld-compatible-benchmark-direction"
        },
        {
          "title": "Evaluation flow",
          "anchor": "evaluation-flow"
        },
        {
          "title": "Desktop readiness metrics",
          "anchor": "desktop-readiness-metrics"
        },
        {
          "title": "Sandbox workflow metrics",
          "anchor": "sandbox-workflow-metrics"
        },
        {
          "title": "What customers see",
          "anchor": "what-customers-see"
        },
        {
          "title": "V1 scope",
          "anchor": "v1-scope"
        },
        {
          "title": "Use cases",
          "anchor": "use-cases"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Evaluations\n\nEvaluations help you answer a simple question: is your agent actually getting work done on a real computer or sandbox, and how long does the work take?\n\nMIOSA evaluations cover three layers:\n\n| Layer | What it measures |\n|---|---|\n| **Sandbox workflow** | create, write files, run commands, expose a preview, publish, and clean up |\n| **Desktop workflow** | boot a Computer, open a browser, screenshot, click, type, scroll, and observe the result |\n| **Agent task** | give an agent a g"
    },
    {
      "slug": "fundamentals",
      "path": "/docs/fundamentals",
      "url": "https://miosa.ai/docs/fundamentals",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/fundamentals",
      "title": "Fundamental Concepts",
      "description": "The mental model every MIOSA integrator needs  -  workspace, authentication, resources, attribution, idempotency, rate limits, errors, and events.",
      "source": "src/routes/docs/fundamentals/+page.md",
      "headings": [
        {
          "title": "1. Organization, workspaces, and projects",
          "anchor": "1-organization-workspaces-and-projects"
        },
        {
          "title": "2. Authentication",
          "anchor": "2-authentication"
        },
        {
          "title": "API keys",
          "anchor": "api-keys"
        },
        {
          "title": "Browser tokens",
          "anchor": "browser-tokens"
        },
        {
          "title": "3. Ownership and external attribution",
          "anchor": "3-ownership-and-external-attribution"
        },
        {
          "title": "4. The six resources",
          "anchor": "4-the-six-resources"
        },
        {
          "title": "5. Token types",
          "anchor": "5-token-types"
        },
        {
          "title": "7. Idempotency",
          "anchor": "7-idempotency"
        },
        {
          "title": "8. Rate limits",
          "anchor": "8-rate-limits"
        },
        {
          "title": "9. Tenant-level configuration",
          "anchor": "9-tenant-level-configuration"
        },
        {
          "title": "Preview domain",
          "anchor": "preview-domain"
        },
        {
          "title": "Branding",
          "anchor": "branding"
        },
        {
          "title": "Webhooks",
          "anchor": "webhooks"
        },
        {
          "title": "Per-end-user quotas",
          "anchor": "per-end-user-quotas"
        },
        {
          "title": "10. Errors",
          "anchor": "10-errors"
        },
        {
          "title": "10. Events (SSE)",
          "anchor": "10-events-sse"
        },
        {
          "title": "Sandbox lifecycle events",
          "anchor": "sandbox-lifecycle-events"
        },
        {
          "title": "Deployment lifecycle events",
          "anchor": "deployment-lifecycle-events"
        },
        {
          "title": "Tenant-wide SSE stream",
          "anchor": "tenant-wide-sse-stream"
        },
        {
          "title": "11. Sandboxes vs Computers",
          "anchor": "11-sandboxes-vs-computers"
        },
        {
          "title": "What's next",
          "anchor": "whats-next"
        }
      ],
      "content_excerpt": "# Fundamental Concepts\n\nMIOSA is a cloud platform for building and deploying applications. Before writing your first API call, read this page. It covers the eight concepts that underpin every MIOSA integration.\n\n---\n\n## 1. Organization, workspaces, and projects\n\nYour MIOSA account starts as one **organization**. The organization has a permanent slug, one billing account, and API keys. Inside it, you can create multiple **workspaces** and **projects**:\n\n- The organization is the authorization and"
    },
    {
      "slug": "glossary",
      "path": "/docs/glossary",
      "url": "https://miosa.ai/docs/glossary",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/glossary",
      "title": "MIOSA Glossary",
      "description": "Plain-language definitions for MIOSA resources, deployment stages, domains, agent workflows, data, and billing.",
      "source": "src/routes/docs/glossary/+page.md",
      "headings": [
        {
          "title": "Learn the flow first",
          "anchor": "learn-the-flow-first"
        },
        {
          "title": "Ownership and organization",
          "anchor": "ownership-and-organization"
        },
        {
          "title": "Building and development",
          "anchor": "building-and-development"
        },
        {
          "title": "Computers and interactive desktops",
          "anchor": "computers-and-interactive-desktops"
        },
        {
          "title": "Publishing and production",
          "anchor": "publishing-and-production"
        },
        {
          "title": "Domains and routing",
          "anchor": "domains-and-routing"
        },
        {
          "title": "Customer infrastructure",
          "anchor": "customer-infrastructure"
        },
        {
          "title": "Agents and automation",
          "anchor": "agents-and-automation"
        },
        {
          "title": "Data, configuration, and security",
          "anchor": "data-configuration-and-security"
        },
        {
          "title": "Usage and billing",
          "anchor": "usage-and-billing"
        },
        {
          "title": "Relationships worth remembering",
          "anchor": "relationships-worth-remembering"
        },
        {
          "title": "Example: from idea to production",
          "anchor": "example-from-idea-to-production"
        },
        {
          "title": "Keep learning",
          "anchor": "keep-learning"
        }
      ],
      "content_excerpt": "# MIOSA Glossary\n\nUse this glossary when a product screen, API response, or guide introduces an unfamiliar MIOSA term.\n\nDefinitions describe the customer-visible product model.\nThey intentionally leave out private infrastructure and implementation details.\n\nBuild and test inside a **Sandbox**.\nPublish immutable code as a **Release** and **Version**.\nPromote that Version through a stable **Deployment** and **Domain**.\nUse a **Computer** when an agent needs a full interactive desktop instead of a "
    },
    {
      "slug": "guides/agent",
      "path": "/docs/guides/agent",
      "url": "https://miosa.ai/docs/guides/agent",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/agent",
      "title": "Integrating an AI agent",
      "description": "How to bring your own AI agent and drive MIOSA Sandbox or Computer primitives to build, run, and deploy applications autonomously.",
      "source": "src/routes/docs/guides/agent/+page.md",
      "headings": [
        {
          "title": "The pattern",
          "anchor": "the-pattern"
        },
        {
          "title": "Sandbox integration",
          "anchor": "sandbox-integration"
        },
        {
          "title": "Computer integration",
          "anchor": "computer-integration"
        },
        {
          "title": "State tracking",
          "anchor": "state-tracking"
        },
        {
          "title": "Approval workflows",
          "anchor": "approval-workflows"
        },
        {
          "title": "Streaming events",
          "anchor": "streaming-events"
        },
        {
          "title": "Best practices",
          "anchor": "best-practices"
        },
        {
          "title": "Examples",
          "anchor": "examples"
        }
      ],
      "content_excerpt": "# Integrating an AI agent\n\nMIOSA provides the substrate: sandboxes, computers, file I/O, exec, previews,\nand snapshots. You provide the agent loop: the LLM calls, screenshot decoding,\nplanning, and turn management. This guide shows how to wire the two together.\n\nIf you are designing the product surface around agents, start with\n[What MIOSA agents can do](/docs/guides/agent-capabilities/),\n[Configure an agent](/docs/guides/configure-agent/), and\n[Agent devices](/docs/guides/agent-devices/). This "
    },
    {
      "slug": "guides/agent-capabilities",
      "path": "/docs/guides/agent-capabilities",
      "url": "https://miosa.ai/docs/guides/agent-capabilities",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/agent-capabilities",
      "title": "What MIOSA agents can do",
      "description": "Built-in tools, connected app actions, device execution, artifacts, browser work, and the permission model for agents running on MIOSA.",
      "source": "src/routes/docs/guides/agent-capabilities/+page.md",
      "headings": [
        {
          "title": "Built-in toolkits",
          "anchor": "built-in-toolkits"
        },
        {
          "title": "Tools in action",
          "anchor": "tools-in-action"
        },
        {
          "title": "Web research",
          "anchor": "web-research"
        },
        {
          "title": "Code execution on a workspace device",
          "anchor": "code-execution-on-a-workspace-device"
        },
        {
          "title": "Browser automation",
          "anchor": "browser-automation"
        },
        {
          "title": "Artifact generation",
          "anchor": "artifact-generation"
        },
        {
          "title": "App actions",
          "anchor": "app-actions"
        },
        {
          "title": "Sub-agent delegation",
          "anchor": "sub-agent-delegation"
        },
        {
          "title": "Device execution",
          "anchor": "device-execution"
        },
        {
          "title": "Permissions",
          "anchor": "permissions"
        },
        {
          "title": "Product surfaces to expose",
          "anchor": "product-surfaces-to-expose"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# What MIOSA agents can do\n\nMIOSA agents are workers that can use real cloud execution. They can research,\nwrite code, run commands, edit files, control a browser or desktop, call\nconnected apps, create artifacts, start previews, and publish finished apps.\n\nThese are the primitives behind products such as Polsia-style autonomous\ncompany operators, Cofounder / Co-Founder AI-style business agents, and\nNebula-style shared virtual devices.\n\nThe core rule is simple: the agent should do the work insid"
    },
    {
      "slug": "guides/agent-company-reference-map",
      "path": "/docs/guides/agent-company-reference-map",
      "url": "https://miosa.ai/docs/guides/agent-company-reference-map",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/agent-company-reference-map",
      "title": "Agent product reference map",
      "description": "Reference products and implementation patterns for building Genspark, Emergent, Blackbox AI, Lovable, Replit, Cofounder, Polsia, Nebula, and BusinessOS-style products on MIOSA.",
      "source": "src/routes/docs/guides/agent-company-reference-map/+page.md",
      "headings": [
        {
          "title": "Reference links",
          "anchor": "reference-links"
        },
        {
          "title": "App builders and generated software products",
          "anchor": "app-builders-and-generated-software-products"
        },
        {
          "title": "Agent-company, virtual-device, and business-operator products",
          "anchor": "agent-company-virtual-device-and-business-operator-products"
        },
        {
          "title": "What the references have in common",
          "anchor": "what-the-references-have-in-common"
        },
        {
          "title": "App-builder architecture",
          "anchor": "app-builder-architecture"
        },
        {
          "title": "App-builder implementation checklist",
          "anchor": "app-builder-implementation-checklist"
        },
        {
          "title": "Cofounder-style company OS on MIOSA",
          "anchor": "cofounder-style-company-os-on-miosa"
        },
        {
          "title": "MIOSA BusinessOS reference",
          "anchor": "miosa-businessos-reference"
        },
        {
          "title": "Founder guide implementation map",
          "anchor": "founder-guide-implementation-map"
        },
        {
          "title": "Start loop",
          "anchor": "start-loop"
        },
        {
          "title": "Build loop",
          "anchor": "build-loop"
        },
        {
          "title": "Sell loop",
          "anchor": "sell-loop"
        },
        {
          "title": "Scale loop",
          "anchor": "scale-loop"
        },
        {
          "title": "Reference architecture",
          "anchor": "reference-architecture"
        },
        {
          "title": "Open-repo patterns to borrow",
          "anchor": "open-repo-patterns-to-borrow"
        },
        {
          "title": "Product implementation checklist",
          "anchor": "product-implementation-checklist"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Agent product reference map\n\nThis page maps public app-builder, agent-company, virtual-device, and open\nworkspace products to MIOSA implementation patterns. Use it when you want to\nbuild a product where agents create apps, operate a business, share persistent\ndevices, create artifacts, run browser work, publish apps, and keep working in\nthe background.\n\nThe links below are references for product architecture and workflow shape. The\nimplementation should use MIOSA primitives: agents, devices, c"
    },
    {
      "slug": "guides/agent-device-selection",
      "path": "/docs/guides/agent-device-selection",
      "url": "https://miosa.ai/docs/guides/agent-device-selection",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/agent-device-selection",
      "title": "Agent device selection",
      "description": "Decide when an agent needs no device, a sandbox, a computer, a local device, or a deployment target.",
      "source": "src/routes/docs/guides/agent-device-selection/+page.md",
      "headings": [
        {
          "title": "The short rule",
          "anchor": "the-short-rule"
        },
        {
          "title": "When no device is required",
          "anchor": "when-no-device-is-required"
        },
        {
          "title": "When a sandbox is required",
          "anchor": "when-a-sandbox-is-required"
        },
        {
          "title": "When a computer is required",
          "anchor": "when-a-computer-is-required"
        },
        {
          "title": "When a local device is required",
          "anchor": "when-a-local-device-is-required"
        },
        {
          "title": "When deployment is required",
          "anchor": "when-deployment-is-required"
        },
        {
          "title": "Examples by agent role",
          "anchor": "examples-by-agent-role"
        },
        {
          "title": "Research agent",
          "anchor": "research-agent"
        },
        {
          "title": "Sales copy agent",
          "anchor": "sales-copy-agent"
        },
        {
          "title": "Engineering agent",
          "anchor": "engineering-agent"
        },
        {
          "title": "Support agent",
          "anchor": "support-agent"
        },
        {
          "title": "Decision tree",
          "anchor": "decision-tree"
        },
        {
          "title": "Cost and performance guidance",
          "anchor": "cost-and-performance-guidance"
        },
        {
          "title": "Backend routing policy",
          "anchor": "backend-routing-policy"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Agent device selection\n\nNot every agent needs a sandbox. The right question is:\n\n```text\nDoes this agent need an execution environment, durable state, files, browser,\nprivate network access, or deployable output?\n```\n\nIf the answer is yes, assign a device. If the answer is no, the agent can run\nas a lightweight orchestration or reasoning step in your backend.\n\n---\n\n## The short rule\n\n| Agent task | Device |\n|---|---|\n| Pure reasoning, classification, routing, summarization | No device required"
    },
    {
      "slug": "guides/agent-devices",
      "path": "/docs/guides/agent-devices",
      "url": "https://miosa.ai/docs/guides/agent-devices",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/agent-devices",
      "title": "Agent devices",
      "description": "MIOSA's device model for agent work: sandbox workers, computers, local devices, primary devices, persistence, and App Engine boundaries.",
      "source": "src/routes/docs/guides/agent-devices/+page.md",
      "headings": [
        {
          "title": "Device selection",
          "anchor": "device-selection"
        },
        {
          "title": "Sandbox vs computer vs BYOC/OpenComputer",
          "anchor": "sandbox-vs-computer-vs-byocopencomputer"
        },
        {
          "title": "How devices relate",
          "anchor": "how-devices-relate"
        },
        {
          "title": "Sandbox Worker",
          "anchor": "sandbox-worker"
        },
        {
          "title": "Sandbox capabilities",
          "anchor": "sandbox-capabilities"
        },
        {
          "title": "Computer",
          "anchor": "computer"
        },
        {
          "title": "Computer capabilities",
          "anchor": "computer-capabilities"
        },
        {
          "title": "Local Device / BYOC / OpenComputer",
          "anchor": "local-device-byoc-opencomputer"
        },
        {
          "title": "Primary device",
          "anchor": "primary-device"
        },
        {
          "title": "Persistence",
          "anchor": "persistence"
        },
        {
          "title": "Activity and timeout",
          "anchor": "activity-and-timeout"
        },
        {
          "title": "Device permissions",
          "anchor": "device-permissions"
        },
        {
          "title": "Building virtual-device products",
          "anchor": "building-virtual-device-products"
        },
        {
          "title": "Related",
          "anchor": "related"
        }
      ],
      "content_excerpt": "# Agent devices\n\nDevices are the machines agents use to do real work. MIOSA has three active\ndevice classes and one hosting target:\n\n| Type | Product meaning |\n|---|---|\n| Sandbox Worker | Isolated code/file/build/preview/artifact workspace |\n| Computer | Persistent cloud desktop/browser with screenshot and input APIs |\n| Local Device / BYOC / OpenComputer | Paired user-owned host for local files, apps, private network access, or customer-owned capacity |\n| App Engine | Durable app-container hos"
    },
    {
      "slug": "guides/agent-operating-guide",
      "path": "/docs/guides/agent-operating-guide",
      "url": "https://miosa.ai/docs/guides/agent-operating-guide",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/agent-operating-guide",
      "title": "Agent operating guide",
      "description": "The authoritative CLI and release workflow for AI agents using MIOSA.",
      "source": "src/routes/docs/guides/agent-operating-guide/+page.md",
      "headings": [
        {
          "title": "Start with discovery",
          "anchor": "start-with-discovery"
        },
        {
          "title": "Resolve scope before mutation",
          "anchor": "resolve-scope-before-mutation"
        },
        {
          "title": "Develop in a persistent sandbox",
          "anchor": "develop-in-a-persistent-sandbox"
        },
        {
          "title": "Preview before production",
          "anchor": "preview-before-production"
        },
        {
          "title": "Verify one exact release",
          "anchor": "verify-one-exact-release"
        },
        {
          "title": "Promote the exact candidate",
          "anchor": "promote-the-exact-candidate"
        },
        {
          "title": "Recover interrupted operations",
          "anchor": "recover-interrupted-operations"
        },
        {
          "title": "Roll back deliberately",
          "anchor": "roll-back-deliberately"
        },
        {
          "title": "Interpret status correctly",
          "anchor": "interpret-status-correctly"
        },
        {
          "title": "Preserve durable resources",
          "anchor": "preserve-durable-resources"
        },
        {
          "title": "Capability boundaries",
          "anchor": "capability-boundaries"
        },
        {
          "title": "Choose the next guide",
          "anchor": "choose-the-next-guide"
        }
      ],
      "content_excerpt": "# Agent operating guide\n\nUse this page when an AI agent, coding assistant, CI worker, or operator needs to build and release software through MIOSA.\n\nThe CLI is the authoritative happy path.\n\nPrefer its typed JSON output and `next_actions` over reconstructing lower-level API calls.\n\n## Start with discovery\n\n```bash\nmiosa capabilities --json\nmiosa app inspect ./app --json\nmiosa app plan ./app --goal deploy --json\n```\n\n`capabilities` reports the installed CLI contract.\n\n`app inspect` detects the f"
    },
    {
      "slug": "guides/agent-orchestration",
      "path": "/docs/guides/agent-orchestration",
      "url": "https://miosa.ai/docs/guides/agent-orchestration",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/agent-orchestration",
      "title": "Agent orchestration",
      "description": "How to coordinate multiple agents across MIOSA sandboxes, computers, artifacts, previews, events, and deployments.",
      "source": "src/routes/docs/guides/agent-orchestration/+page.md",
      "headings": [
        {
          "title": "Scale model: from one agent to thousands",
          "anchor": "scale-model-from-one-agent-to-thousands"
        },
        {
          "title": "Prompt dispatch",
          "anchor": "prompt-dispatch"
        },
        {
          "title": "Durable run groups",
          "anchor": "durable-run-groups"
        },
        {
          "title": "Exporting generated work",
          "anchor": "exporting-generated-work"
        },
        {
          "title": "Subagents inside sandboxes",
          "anchor": "subagents-inside-sandboxes"
        },
        {
          "title": "Sandbox-hosted orchestrators",
          "anchor": "sandbox-hosted-orchestrators"
        },
        {
          "title": "Self-configuring agents",
          "anchor": "self-configuring-agents"
        },
        {
          "title": "Credentials and account connection",
          "anchor": "credentials-and-account-connection"
        },
        {
          "title": "Queue and pool architecture",
          "anchor": "queue-and-pool-architecture"
        },
        {
          "title": "Mental model",
          "anchor": "mental-model"
        },
        {
          "title": "Runtime selection",
          "anchor": "runtime-selection"
        },
        {
          "title": "Example: app builder with browser QA",
          "anchor": "example-app-builder-with-browser-qa"
        },
        {
          "title": "Communication primitives",
          "anchor": "communication-primitives"
        },
        {
          "title": "Product UI pattern",
          "anchor": "product-ui-pattern"
        },
        {
          "title": "Minimal orchestrator shape",
          "anchor": "minimal-orchestrator-shape"
        },
        {
          "title": "Sandbox-first code agent",
          "anchor": "sandbox-first-code-agent"
        },
        {
          "title": "Computer QA agent",
          "anchor": "computer-qa-agent"
        },
        {
          "title": "Permissions and safety",
          "anchor": "permissions-and-safety"
        },
        {
          "title": "When to use ADK vs your own orchestrator",
          "anchor": "when-to-use-adk-vs-your-own-orchestrator"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Agent orchestration\n\nMIOSA lets you build agent systems where different agents use the right runtime\nfor each part of the job.\n\n- A **sandbox agent** writes code, edits files, runs commands, builds packages,\n  generates artifacts, and exposes preview ports.\n- A **computer agent** uses a real browser or desktop for visual checks, clicks,\n  form fills, screenshots, uploads, and human handoff.\n- A **deployment agent** promotes a verified sandbox workspace into a production\n  deployment or App Eng"
    },
    {
      "slug": "guides/agent-product-model",
      "path": "/docs/guides/agent-product-model",
      "url": "https://miosa.ai/docs/guides/agent-product-model",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/agent-product-model",
      "title": "Agent product model",
      "description": "The canonical MIOSA model for agents, devices, runs, tools, artifacts, credits, and deployments.",
      "source": "src/routes/docs/guides/agent-product-model/+page.md",
      "headings": [
        {
          "title": "Core primitives",
          "anchor": "core-primitives"
        },
        {
          "title": "Boundary",
          "anchor": "boundary"
        },
        {
          "title": "Product categories",
          "anchor": "product-categories"
        },
        {
          "title": "Product stack",
          "anchor": "product-stack"
        },
        {
          "title": "Canonical run shape",
          "anchor": "canonical-run-shape"
        },
        {
          "title": "Event stream",
          "anchor": "event-stream"
        },
        {
          "title": "What gets billed",
          "anchor": "what-gets-billed"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Agent product model\n\nMIOSA lets builders create products where agents do real work in cloud devices.\nThe product model is deliberately small:\n\n```text\nAgent + Device + Tools + Run stream + Artifacts + Credits\n```\n\nThat model supports simple one-shot commands, generated app builders, browser\nautomation, artifact workspaces, 24/7 company operators, white-label SaaS\nbackends, and multi-agent fleets.\n\nUse this page as the canonical vocabulary for products built on MIOSA.\n\n---\n\n## Core primitives\n\n"
    },
    {
      "slug": "guides/agent-runtime-routing",
      "path": "/docs/guides/agent-runtime-routing",
      "url": "https://miosa.ai/docs/guides/agent-runtime-routing",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/agent-runtime-routing",
      "title": "Agent runtime routing",
      "description": "How MIOSA routes prompts to OSA, Codex, Claude Code, Pi, Hermes, custom runtimes, and assigned devices.",
      "source": "src/routes/docs/guides/agent-runtime-routing/+page.md",
      "headings": [
        {
          "title": "Routing contract",
          "anchor": "routing-contract"
        },
        {
          "title": "Runtime choices",
          "anchor": "runtime-choices"
        },
        {
          "title": "Device choices",
          "anchor": "device-choices"
        },
        {
          "title": "Non-interactive first",
          "anchor": "non-interactive-first"
        },
        {
          "title": "Runtime adapter lifecycle",
          "anchor": "runtime-adapter-lifecycle"
        },
        {
          "title": "Model availability",
          "anchor": "model-availability"
        },
        {
          "title": "Credential injection",
          "anchor": "credential-injection"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Agent runtime routing\n\nAn agent run has two separate choices:\n\n1. **Which runtime thinks and acts?**\n2. **Which device executes the work?**\n\nThe runtime can be OSA, Codex, Claude Code, Pi, Hermes, Gemini CLI, OpenCode,\nor a custom agent harness. The device can be a sandbox, computer, or local\ndevice.\n\n```text\nMIOSA Agent = runtime, model, instructions, tools, policy\nMIOSA Device = sandbox, computer, or local machine where actions happen\n```\n\n---\n\n## Routing contract\n\n```typescript\ntype Runtime"
    },
    {
      "slug": "guides/agent-workflow-patterns",
      "path": "/docs/guides/agent-workflow-patterns",
      "url": "https://miosa.ai/docs/guides/agent-workflow-patterns",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/agent-workflow-patterns",
      "title": "Agent workflow patterns",
      "description": "Simple-to-complex workflows for using MIOSA agents, devices, events, artifacts, and deployments.",
      "source": "src/routes/docs/guides/agent-workflow-patterns/+page.md",
      "headings": [
        {
          "title": "Pattern 1: one-shot run",
          "anchor": "pattern-1-one-shot-run"
        },
        {
          "title": "Pattern 2: prompt into a sandbox",
          "anchor": "pattern-2-prompt-into-a-sandbox"
        },
        {
          "title": "Pattern 3: prompt into a computer",
          "anchor": "pattern-3-prompt-into-a-computer"
        },
        {
          "title": "Pattern 4: detached agent session",
          "anchor": "pattern-4-detached-agent-session"
        },
        {
          "title": "Pattern 5: app-builder loop",
          "anchor": "pattern-5-app-builder-loop"
        },
        {
          "title": "Pattern 6: artifact workspace",
          "anchor": "pattern-6-artifact-workspace"
        },
        {
          "title": "Pattern 7: browser operator",
          "anchor": "pattern-7-browser-operator"
        },
        {
          "title": "Pattern 8: orchestrated agent team",
          "anchor": "pattern-8-orchestrated-agent-team"
        },
        {
          "title": "Pattern 9: agent fleet",
          "anchor": "pattern-9-agent-fleet"
        },
        {
          "title": "Choosing the pattern",
          "anchor": "choosing-the-pattern"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Agent workflow patterns\n\nMIOSA workflows scale from a single prompt to a fleet of long-running agents.\nThe same primitives apply at every level:\n\n```text\nprompt -> agent runtime -> assigned device -> event stream -> durable output\n```\n\nUse this page to choose the right workflow for your product.\n\n---\n\n## Pattern 1: one-shot run\n\nUse this for quick checks, small scripts, inspections, summaries, and health\ntests.\n\n```bash\nmiosa run \"check if the preview server is healthy\" --device sandbox:<id>\n`"
    },
    {
      "slug": "guides/build-agent-company",
      "path": "/docs/guides/build-agent-company",
      "url": "https://miosa.ai/docs/guides/build-agent-company",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/build-agent-company",
      "title": "Build your own AI platform",
      "description": "Build your own Genspark, Emergent, Blackbox AI, Lovable, Replit, Polsia, Cofounder, or Nebula-style product on MIOSA.",
      "source": "src/routes/docs/guides/build-agent-company/+page.md",
      "headings": [
        {
          "title": "Reference products and repos",
          "anchor": "reference-products-and-repos"
        },
        {
          "title": "What these products have in common",
          "anchor": "what-these-products-have-in-common"
        },
        {
          "title": "What requires a device",
          "anchor": "what-requires-a-device"
        },
        {
          "title": "Reference architecture",
          "anchor": "reference-architecture"
        },
        {
          "title": "Implementation checklist",
          "anchor": "implementation-checklist"
        },
        {
          "title": "E2E runtime profile to artifact export",
          "anchor": "e2e-runtime-profile-to-artifact-export"
        },
        {
          "title": "Prompt-to-device flow",
          "anchor": "prompt-to-device-flow"
        },
        {
          "title": "Runtime profiles and env inheritance",
          "anchor": "runtime-profiles-and-env-inheritance"
        },
        {
          "title": "Artifacts and downloads",
          "anchor": "artifacts-and-downloads"
        },
        {
          "title": "Backend module shape",
          "anchor": "backend-module-shape"
        },
        {
          "title": "Product mapping",
          "anchor": "product-mapping"
        },
        {
          "title": "Build your own Polsia-style operator",
          "anchor": "build-your-own-polsia-style-operator"
        },
        {
          "title": "Build your own Cofounder / Co-Founder AI-style company OS",
          "anchor": "build-your-own-cofounder-co-founder-ai-style-company-os"
        },
        {
          "title": "Build your own Nebula-style virtual device",
          "anchor": "build-your-own-nebula-style-virtual-device"
        },
        {
          "title": "Build Heuresis-style encoded workspaces",
          "anchor": "build-heuresis-style-encoded-workspaces"
        },
        {
          "title": "Implementation path",
          "anchor": "implementation-path"
        },
        {
          "title": "1. Choose the runtime shape",
          "anchor": "1-choose-the-runtime-shape"
        },
        {
          "title": "2. Dispatch prompts into the device",
          "anchor": "2-dispatch-prompts-into-the-device"
        },
        {
          "title": "3. Create or resume the workspace runtime",
          "anchor": "3-create-or-resume-the-workspace-runtime"
        },
        {
          "title": "4. Make the agent write inside the device",
          "anchor": "4-make-the-agent-write-inside-the-device"
        },
        {
          "title": "5. Stream progress into the product UI",
          "anchor": "5-stream-progress-into-the-product-ui"
        },
        {
          "title": "6. Attach connectors and secrets safely",
          "anchor": "6-attach-connectors-and-secrets-safely"
        },
        {
          "title": "7. Save checkpoints and publish",
          "anchor": "7-save-checkpoints-and-publish"
        },
        {
          "title": "What your frontend should show",
          "anchor": "what-your-frontend-should-show"
        },
        {
          "title": "Architecture rules",
          "anchor": "architecture-rules"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Build your own AI platform\n\nYou can use MIOSA to build your own product in the same category as **Genspark**, **Emergent**, **Blackbox AI**, **Lovable**, **Replit Agent**, **Polsia**, **Cofounder**, or **Nebula**.\n\nYour product owns the brand, customer experience, prompts, model routing, billing, and workflow.\nMIOSA supplies the execution layer: sandboxes, computers, files, commands, previews, artifacts, snapshots, connectors, events, data services, and immutable deployments.\n\nThis guide maps "
    },
    {
      "slug": "guides/configure-agent",
      "path": "/docs/guides/configure-agent",
      "url": "https://miosa.ai/docs/guides/configure-agent",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/configure-agent",
      "title": "Configure an agent",
      "description": "Configure an agent's identity, instructions, model, devices, tools, memory, connected accounts, triggers, and approval policy.",
      "source": "src/routes/docs/guides/configure-agent/+page.md",
      "headings": [
        {
          "title": "Configuration checklist",
          "anchor": "configuration-checklist"
        },
        {
          "title": "Identity",
          "anchor": "identity"
        },
        {
          "title": "Visibility",
          "anchor": "visibility"
        },
        {
          "title": "Instructions",
          "anchor": "instructions"
        },
        {
          "title": "Model and runtime",
          "anchor": "model-and-runtime"
        },
        {
          "title": "Runtime profiles",
          "anchor": "runtime-profiles"
        },
        {
          "title": "Default device",
          "anchor": "default-device"
        },
        {
          "title": "Tools",
          "anchor": "tools"
        },
        {
          "title": "Accounts and variables",
          "anchor": "accounts-and-variables"
        },
        {
          "title": "Memory",
          "anchor": "memory"
        },
        {
          "title": "Triggers and jobs",
          "anchor": "triggers-and-jobs"
        },
        {
          "title": "Approval policy",
          "anchor": "approval-policy"
        },
        {
          "title": "Related",
          "anchor": "related"
        }
      ],
      "content_excerpt": "# Configure an agent\n\nAn agent is a named worker with instructions, tools, devices, memory, connected\naccounts, and approval rules. The goal is to make the agent predictable enough\nto trust, but capable enough to do real work inside MIOSA sandboxes and\ncomputers.\n\n---\n\n## Configuration checklist\n\n| Setting | Why it matters |\n|---|---|\n| Name and description | Helps users and orchestrators route work to the right agent |\n| Visibility | Private, workspace, or platform-managed |\n| Instructions | Ro"
    },
    {
      "slug": "guides/managed-connectors",
      "path": "/docs/guides/managed-connectors",
      "url": "https://miosa.ai/docs/guides/managed-connectors",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/managed-connectors",
      "title": "Managed connectors for sandbox agents",
      "description": "Attach MIOSA-managed tools like Refero to sandbox or computer agents without client-supplied vendor tokens.",
      "source": "src/routes/docs/guides/managed-connectors/+page.md",
      "headings": [
        {
          "title": "Connectors, egress, and MCP",
          "anchor": "connectors-egress-and-mcp"
        },
        {
          "title": "Default flow",
          "anchor": "default-flow"
        },
        {
          "title": "How the token works",
          "anchor": "how-the-token-works"
        },
        {
          "title": "MCP config inside the sandbox",
          "anchor": "mcp-config-inside-the-sandbox"
        },
        {
          "title": "Tenant-provided connectors",
          "anchor": "tenant-provided-connectors"
        },
        {
          "title": "Which runtime should I use?",
          "anchor": "which-runtime-should-i-use"
        }
      ],
      "content_excerpt": "# Managed connectors for sandbox agents\n\nMIOSA agents should build inside MIOSA sandboxes or computers. The local CLI or\nMCP client should orchestrate the work; the sandbox/computer should be where the\nagent writes files, installs packages, runs commands, previews apps, and\nproduces artifacts.\n\nManaged connectors give those in-VM agents tools without asking every client to\nbring vendor credentials.\n\n## Connectors, egress, and MCP\n\nThese three surfaces work together, but they are not interchangea"
    },
    {
      "slug": "guides/mcp",
      "path": "/docs/guides/mcp",
      "url": "https://miosa.ai/docs/guides/mcp",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/mcp",
      "title": "MCP server",
      "description": "Connect any AI agent to MIOSA's 145-tool MCP server  -  hosted (zero install) or local. Drive sandboxes, computers, deployments, databases, storage, and more from Claude Code, Cursor, Windsurf, or your own agent loop.",
      "source": "src/routes/docs/guides/mcp/+page.md",
      "headings": [
        {
          "title": "Two ways to use MCP",
          "anchor": "two-ways-to-use-mcp"
        },
        {
          "title": "Hosted (zero install)  -  recommended",
          "anchor": "hosted-zero-install-recommended"
        },
        {
          "title": "Local server",
          "anchor": "local-server"
        },
        {
          "title": "How it works",
          "anchor": "how-it-works"
        },
        {
          "title": "Configuration",
          "anchor": "configuration"
        },
        {
          "title": "Claude Code",
          "anchor": "claude-code"
        },
        {
          "title": "Cursor",
          "anchor": "cursor"
        },
        {
          "title": "Windsurf",
          "anchor": "windsurf"
        },
        {
          "title": "Environment variable reference (local server only)",
          "anchor": "environment-variable-reference-local-server-only"
        },
        {
          "title": "Live tool catalog",
          "anchor": "live-tool-catalog"
        },
        {
          "title": "Computer lifecycle",
          "anchor": "computer-lifecycle"
        },
        {
          "title": "Desktop control",
          "anchor": "desktop-control"
        },
        {
          "title": "File I/O",
          "anchor": "file-io"
        },
        {
          "title": "Checkpoints",
          "anchor": "checkpoints"
        },
        {
          "title": "Services",
          "anchor": "services"
        },
        {
          "title": "Env / Logs / Domains",
          "anchor": "env-logs-domains"
        },
        {
          "title": "Sandbox",
          "anchor": "sandbox"
        },
        {
          "title": "Deployments",
          "anchor": "deployments"
        },
        {
          "title": "Storage",
          "anchor": "storage"
        },
        {
          "title": "Databases",
          "anchor": "databases"
        },
        {
          "title": "Workspaces",
          "anchor": "workspaces"
        },
        {
          "title": "Cron",
          "anchor": "cron"
        },
        {
          "title": "Volumes",
          "anchor": "volumes"
        },
        {
          "title": "Webhooks",
          "anchor": "webhooks"
        },
        {
          "title": "Functions",
          "anchor": "functions"
        },
        {
          "title": "API Keys",
          "anchor": "api-keys"
        },
        {
          "title": "Network",
          "anchor": "network"
        },
        {
          "title": "Ports",
          "anchor": "ports"
        },
        {
          "title": "Billing",
          "anchor": "billing"
        },
        {
          "title": "Regions (1 tool)",
          "anchor": "regions-1-tool"
        },
        {
          "title": "Settings",
          "anchor": "settings"
        },
        {
          "title": "Usage examples",
          "anchor": "usage-examples"
        },
        {
          "title": "Create a computer and take a screenshot",
          "anchor": "create-a-computer-and-take-a-screenshot"
        },
        {
          "title": "Deploy a sandbox to production",
          "anchor": "deploy-a-sandbox-to-production"
        },
        {
          "title": "Set up a cron job",
          "anchor": "set-up-a-cron-job"
        },
        {
          "title": "Create a database and get credentials",
          "anchor": "create-a-database-and-get-credentials"
        },
        {
          "title": "Troubleshooting",
          "anchor": "troubleshooting"
        },
        {
          "title": "Security considerations",
          "anchor": "security-considerations"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# MCP server\n\nThe MIOSA MCP (Model Context Protocol) server exposes a live, capability-scoped tool catalog.\nAI coding assistants can create sandboxes, run commands, write files, take computer screenshots, and manage deployments, storage, databases, and other authorized resources without leaving the editor.\nThe server speaks the MCP transport protocol, so any compliant client can drive it.\n\nThe exact tool list depends on the authenticated caller, server release, and enabled capabilities.\nUse MCP "
    },
    {
      "slug": "guides/runtime-env",
      "path": "/docs/guides/runtime-env",
      "url": "https://miosa.ai/docs/guides/runtime-env",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/runtime-env",
      "title": "Runtime env for agent devices",
      "description": "Define inherited environment variables for sandboxes, computers, and agent runtimes at tenant, workspace, or project scope.",
      "source": "src/routes/docs/guides/runtime-env/+page.md",
      "headings": [
        {
          "title": "Scope model",
          "anchor": "scope-model"
        },
        {
          "title": "Target model",
          "anchor": "target-model"
        },
        {
          "title": "Common patterns",
          "anchor": "common-patterns"
        },
        {
          "title": "CLI",
          "anchor": "cli"
        },
        {
          "title": "SDKs",
          "anchor": "sdks"
        },
        {
          "title": "Verify inside a sandbox",
          "anchor": "verify-inside-a-sandbox"
        },
        {
          "title": "Verify inside a computer",
          "anchor": "verify-inside-a-computer"
        },
        {
          "title": "Verify inside an agent run",
          "anchor": "verify-inside-an-agent-run"
        },
        {
          "title": "Agent runtime profiles and connectors",
          "anchor": "agent-runtime-profiles-and-connectors"
        },
        {
          "title": "Export generated work",
          "anchor": "export-generated-work"
        }
      ],
      "content_excerpt": "# Runtime env for agent devices\n\nRuntime env lets a platform owner define environment variables once and have\nthem inherited by sandboxes, computers, and agent runs. Use it for provider keys,\nmodel configuration, MCP tokens, workspace defaults, and white-label customer\nsettings that should be available automatically when a device starts or runs a\ncommand.\n\nThis is the foundation for products where users create many agent workspaces:\napp builders, browser operators, 24/7 company agents, research "
    },
    {
      "slug": "guides/skills",
      "path": "/docs/guides/skills",
      "url": "https://miosa.ai/docs/guides/skills",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/guides/skills",
      "title": "Claude Code Skills",
      "description": "",
      "source": "src/routes/docs/guides/skills/+page.md",
      "headings": [
        {
          "title": "What you get",
          "anchor": "what-you-get"
        },
        {
          "title": "Install",
          "anchor": "install"
        },
        {
          "title": "Verify",
          "anchor": "verify"
        },
        {
          "title": "How they activate",
          "anchor": "how-they-activate"
        },
        {
          "title": "Structure (official Agent Skills spec)",
          "anchor": "structure-official-agent-skills-spec"
        },
        {
          "title": "What's in each skill",
          "anchor": "whats-in-each-skill"
        },
        {
          "title": "miosa-mcp",
          "anchor": "miosa-mcp"
        },
        {
          "title": "miosa-sandbox",
          "anchor": "miosa-sandbox"
        },
        {
          "title": "miosa-computer",
          "anchor": "miosa-computer"
        },
        {
          "title": "miosa-deploy",
          "anchor": "miosa-deploy"
        },
        {
          "title": "miosa-data",
          "anchor": "miosa-data"
        },
        {
          "title": "Customizing",
          "anchor": "customizing"
        },
        {
          "title": "Why skills instead of CLAUDE.md",
          "anchor": "why-skills-instead-of-claudemd"
        },
        {
          "title": "Updating",
          "anchor": "updating"
        },
        {
          "title": "Related",
          "anchor": "related"
        }
      ],
      "content_excerpt": "# Claude Code Skills for MIOSA\n\nSkills extend Claude Code with MIOSA-specific knowledge. Install them once and Claude automatically loads the right one when you ask for cloud infrastructure  -  no manual prompting.\n\n## What you get\n\n| Skill | What it does |\n|---|---|\n| `miosa-mcp` | Universal entry point  -  explains the 145-tool surface and routes to specific skills |\n| `miosa-sandbox` | Headless code-execution VMs (Python, Node, builds, CI) |\n| `miosa-computer` | Desktop VMs (browser automatio"
    },
    {
      "slug": "infrastructure/byoc/aws",
      "path": "/docs/infrastructure/byoc/aws",
      "url": "https://miosa.ai/docs/infrastructure/byoc/aws",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/infrastructure/byoc/aws",
      "title": "AWS customer-cloud regions",
      "description": "Architecture and readiness contract for running MIOSA worker capacity inside a customer AWS account.",
      "source": "src/routes/docs/infrastructure/byoc/aws/+page.md",
      "headings": [
        {
          "title": "Packaged foundation",
          "anchor": "packaged-foundation"
        },
        {
          "title": "Security architecture",
          "anchor": "security-architecture"
        },
        {
          "title": "Readiness is fail-closed",
          "anchor": "readiness-is-fail-closed"
        },
        {
          "title": "Current maturity",
          "anchor": "current-maturity"
        },
        {
          "title": "What customers will control",
          "anchor": "what-customers-will-control"
        }
      ],
      "content_excerpt": "The AWS path uses customer-reviewed Terraform or CloudFormation to create a private, scoped worker foundation.\n\nActivation gated\nTerraform and CloudFormation validated\n\n## Packaged foundation\n\nThe current AWS packages define:\n\n- A customer-specific external-ID trust boundary.\n- A least-privilege worker instance profile.\n- Private subnets across at least two Availability Zones.\n- An egress-only security group with no inbound rules.\n- Immutable launch-template versions.\n- Encrypted root and XFS co"
    },
    {
      "slug": "infrastructure/byoc/gcp",
      "path": "/docs/infrastructure/byoc/gcp",
      "url": "https://miosa.ai/docs/infrastructure/byoc/gcp",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/infrastructure/byoc/gcp",
      "title": "Google Cloud customer-cloud regions",
      "description": "Architecture and readiness contract for running MIOSA worker capacity inside a customer GCP project.",
      "source": "src/routes/docs/infrastructure/byoc/gcp/+page.md",
      "headings": [
        {
          "title": "Packaged foundation",
          "anchor": "packaged-foundation"
        },
        {
          "title": "Security architecture",
          "anchor": "security-architecture"
        },
        {
          "title": "GCP-specific acceptance",
          "anchor": "gcp-specific-acceptance"
        },
        {
          "title": "Current maturity",
          "anchor": "current-maturity"
        },
        {
          "title": "What customers will control",
          "anchor": "what-customers-will-control"
        }
      ],
      "content_excerpt": "The Google Cloud path uses customer-owned Terraform to create a private worker foundation and reusable instance template.\n\nActivation gated\nTerraform foundation validated\n\n## Packaged foundation\n\nThe current GCP package defines:\n\n- A scoped worker service account.\n- IAM bindings for approved artifacts, telemetry, and one bootstrap secret.\n- A VPC, subnetwork, and firewall rules.\n- A reusable Compute Engine instance template.\n- Optional GCS artifact access.\n- Immutable manifest and checksum input"
    },
    {
      "slug": "infrastructure/byoc/overview",
      "path": "/docs/infrastructure/byoc/overview",
      "url": "https://miosa.ai/docs/infrastructure/byoc/overview",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/infrastructure/byoc/overview",
      "title": "Bring Your Own Cloud",
      "description": "Run MIOSA worker capacity inside a customer AWS account or GCP project while MIOSA orchestrates the product.",
      "source": "src/routes/docs/infrastructure/byoc/overview/+page.md",
      "headings": [
        {
          "title": "Control plane and customer cloud",
          "anchor": "control-plane-and-customer-cloud"
        },
        {
          "title": "What runs where",
          "anchor": "what-runs-where"
        },
        {
          "title": "Provider support",
          "anchor": "provider-support"
        },
        {
          "title": "Customer onboarding path",
          "anchor": "customer-onboarding-path"
        },
        {
          "title": "BYOC compared with OpenComputers",
          "anchor": "byoc-compared-with-opencomputers"
        }
      ],
      "content_excerpt": "Bring Your Own Cloud lets an organization power its product with infrastructure inside its own AWS account or GCP project.\n\nMIOSA remains the orchestration and product control plane.\n\nActivation gated\nInfrastructure packages built\n\n## Control plane and customer cloud\n\nDiagram:\nflowchart LR\n  subgraph M[\"MIOSA control plane\"]\n    Desired[\"Desired state\"]\n    Scheduler[\"Placement and scheduling\"]\n    Acceptance[\"Host acceptance\"]\n    Evidence[\"Health, usage, and evidence\"]\n  end\n\n  subgraph C[\"Cus"
    },
    {
      "slug": "infrastructure/overview",
      "path": "/docs/infrastructure/overview",
      "url": "https://miosa.ai/docs/infrastructure/overview",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/infrastructure/overview",
      "title": "Infrastructure options",
      "description": "Choose between MIOSA-managed compute, OpenComputers, and customer-cloud regions.",
      "source": "src/routes/docs/infrastructure/overview/+page.md",
      "headings": [
        {
          "title": "Choose an infrastructure model",
          "anchor": "choose-an-infrastructure-model"
        },
        {
          "title": "One orchestration layer",
          "anchor": "one-orchestration-layer"
        },
        {
          "title": "Product promise",
          "anchor": "product-promise"
        }
      ],
      "content_excerpt": "MIOSA can orchestrate products across infrastructure operated by MIOSA or controlled by the customer.\n\nThe application keeps one resource model and control plane while placement determines where work executes.\n\n## Choose an infrastructure model\n\n  \n    MIOSA operates the compute, networking, host lifecycle, and capacity.\n\n    Best for fast onboarding and products that do not require a customer-owned cloud boundary.\n  \n  \n    Connect individual machines through an outbound agent session.\n\n    Bes"
    },
    {
      "slug": "infrastructure/shared-responsibility",
      "path": "/docs/infrastructure/shared-responsibility",
      "url": "https://miosa.ai/docs/infrastructure/shared-responsibility",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/infrastructure/shared-responsibility",
      "title": "Shared responsibility",
      "description": "Responsibility boundaries for MIOSA-managed, OpenComputers, and customer-cloud infrastructure.",
      "source": "src/routes/docs/infrastructure/shared-responsibility/+page.md",
      "headings": [
        {
          "title": "Responsibility matrix",
          "anchor": "responsibility-matrix"
        },
        {
          "title": "MIOSA responsibilities",
          "anchor": "miosa-responsibilities"
        },
        {
          "title": "Customer responsibilities",
          "anchor": "customer-responsibilities"
        },
        {
          "title": "Cloud-provider responsibilities",
          "anchor": "cloud-provider-responsibilities"
        },
        {
          "title": "Safe change order",
          "anchor": "safe-change-order"
        }
      ],
      "content_excerpt": "Infrastructure ownership changes who operates each layer.\n\nThe product should make those boundaries visible before a workload is placed.\n\n## Responsibility matrix\n\n| Responsibility | MIOSA-managed | OpenComputers | Bring Your Own Cloud |\n|---|---|---|---|\n| Control-plane service | MIOSA | MIOSA | MIOSA |\n| Physical or cloud account | MIOSA | Customer | Customer |\n| Host operating system | MIOSA | Customer | Shared through certified image and customer account |\n| Host capacity | MIOSA | Customer "
    },
    {
      "slug": "integrations",
      "path": "/docs/integrations",
      "url": "https://miosa.ai/docs/integrations",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/integrations",
      "title": "Build your product on MIOSA",
      "description": "Ship a white-label SaaS where your end-users never see the MIOSA brand. Isolated compute, custom domains, branded previews, usage rollup, and webhooks  -  all under your domain.",
      "source": "src/routes/docs/integrations/+page.md",
      "headings": [
        {
          "title": "Core building blocks",
          "anchor": "core-building-blocks"
        },
        {
          "title": "What white-label tenants get",
          "anchor": "what-white-label-tenants-get"
        },
        {
          "title": "Architecture patterns",
          "anchor": "architecture-patterns"
        },
        {
          "title": "Pattern 1  -  Server-side proxy (recommended for most teams)",
          "anchor": "pattern-1-server-side-proxy-recommended-for-most-teams"
        },
        {
          "title": "Pattern 2  -  Backend-for-Frontend (BFF)",
          "anchor": "pattern-2-backend-for-frontend-bff"
        },
        {
          "title": "Pattern 3  -  Direct with browser tokens",
          "anchor": "pattern-3-direct-with-browser-tokens"
        },
        {
          "title": "Five-minute path for new integrators",
          "anchor": "five-minute-path-for-new-integrators"
        },
        {
          "title": "Example apps",
          "anchor": "example-apps"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Build your product on MIOSA\n\nMIOSA gives you the full compute and preview infrastructure. You own the product, the brand, and the user relationship. Your customers never see \"MIOSA\".\n\nThis section covers everything you need to ship a white-label SaaS on top of MIOSA: per-user provisioning, custom domains, secure iframe embeds, webhooks, usage metering, and abuse controls.\n\n---\n\n## Core building blocks\n\n  \n    Build the server-side control plane for prompt dispatch, device assignment, event str"
    },
    {
      "slug": "integrations/backend-orchestration",
      "path": "/docs/integrations/backend-orchestration",
      "url": "https://miosa.ai/docs/integrations/backend-orchestration",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/integrations/backend-orchestration",
      "title": "Backend orchestration",
      "description": "Backend patterns for dispatching prompts into MIOSA sandboxes, computers, and local devices.",
      "source": "src/routes/docs/integrations/backend-orchestration/+page.md",
      "headings": [
        {
          "title": "Backend responsibilities",
          "anchor": "backend-responsibilities"
        },
        {
          "title": "Reference flow",
          "anchor": "reference-flow"
        },
        {
          "title": "Prompt dispatch contract",
          "anchor": "prompt-dispatch-contract"
        },
        {
          "title": "Backend resource model",
          "anchor": "backend-resource-model"
        },
        {
          "title": "SDK shape",
          "anchor": "sdk-shape"
        },
        {
          "title": "Recovery rules",
          "anchor": "recovery-rules"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Backend orchestration\n\nYour backend is the control plane for products built on MIOSA. It owns the user\nsession, product permissions, billing policy, model routing, agent roster,\nconnector grants, and approval rules. MIOSA owns the execution substrate:\nsandboxes, computers, files, exec, previews, artifacts, events, snapshots, and\ndeployments.\n\nUse this guide when you are building products like app builders, artifact\nworkspaces, Polsia-style operators, Cofounder / Co-Founder AI-style company\nage"
    },
    {
      "slug": "integrations/comparison",
      "path": "/docs/integrations/comparison",
      "url": "https://miosa.ai/docs/integrations/comparison",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/integrations/comparison",
      "title": "Compute Provider Comparison",
      "description": "How MIOSA compares to Orgo, AgentComputer, E2B, Daytona, and ascii Box on pricing, capabilities, and desktop/boot performance. Public data as of 2026-06-09.",
      "source": "src/routes/docs/integrations/comparison/+page.md",
      "headings": [
        {
          "title": "Pricing model",
          "anchor": "pricing-model"
        },
        {
          "title": "Compute cost, normalized",
          "anchor": "compute-cost-normalized"
        },
        {
          "title": "Cost calculator",
          "anchor": "cost-calculator"
        },
        {
          "title": "Capability matrix",
          "anchor": "capability-matrix"
        },
        {
          "title": "Desktop and boot performance",
          "anchor": "desktop-and-boot-performance"
        },
        {
          "title": "Where MIOSA fits best",
          "anchor": "where-miosa-fits-best"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Compute Provider Comparison\n\nHow MIOSA fits alongside other agent-computer and sandbox providers on\n**price**, **capabilities**, and **desktop performance**. Every external number\nis from the vendor's public pricing or docs as of **2026-06-09**. Re-check before\nyou make a buying decision.\n\n<div style=\"display:flex;align-items:center;gap:.75rem;flex-wrap:wrap;margin:1rem 0 1.5rem;\">\n  <span style=\"display:inline-flex;align-items:center;gap:.45rem;padding:.35rem .7rem;border:1px solid #2a2a2a;bo"
    },
    {
      "slug": "integrations/examples",
      "path": "/docs/integrations/examples",
      "url": "https://miosa.ai/docs/integrations/examples",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/integrations/examples",
      "title": "Example Apps",
      "description": "Four full-stack white-label examples you can clone, run locally, and adapt to your own stack.",
      "source": "src/routes/docs/integrations/examples/+page.md",
      "headings": [
        {
          "title": "Pick an example",
          "anchor": "pick-an-example"
        },
        {
          "title": "whitelabel-saas",
          "anchor": "whitelabel-saas"
        },
        {
          "title": "whitelabel-react-saas",
          "anchor": "whitelabel-react-saas"
        },
        {
          "title": "whitelabel-nextjs-marketplace",
          "anchor": "whitelabel-nextjs-marketplace"
        },
        {
          "title": "whitelabel-vue-tutor",
          "anchor": "whitelabel-vue-tutor"
        },
        {
          "title": "Feature matrix",
          "anchor": "feature-matrix"
        },
        {
          "title": "Contributing an example",
          "anchor": "contributing-an-example"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Example apps\n\nFour complete, runnable examples. Each demonstrates a different frontend stack and a different set of white-label capabilities. Clone the repo and follow the \"Run locally\" steps below each entry.\n\nEvery example should pass three proofs before you adapt it: the application starts locally, its MIOSA resource resolves to the intended Workspace and Project, and the browser never receives a server API key.\n\n## Pick an example\n\n| Goal | Start with | Completion proof |\n|---|---|---|\n| S"
    },
    {
      "slug": "integrations/external-computers",
      "path": "/docs/integrations/external-computers",
      "url": "https://miosa.ai/docs/integrations/external-computers",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/integrations/external-computers",
      "title": "External Compute Providers",
      "description": "Connect third-party computer providers to MIOSA while keeping one product API, one billing model, and one user experience.",
      "source": "src/routes/docs/integrations/external-computers/+page.md",
      "headings": [
        {
          "title": "The adapter contract",
          "anchor": "the-adapter-contract"
        },
        {
          "title": "Provider mapping example",
          "anchor": "provider-mapping-example"
        },
        {
          "title": "Orchestrate it with your driver",
          "anchor": "orchestrate-it-with-your-driver"
        },
        {
          "title": "Bring your own harness",
          "anchor": "bring-your-own-harness"
        },
        {
          "title": "Display it in your UI",
          "anchor": "display-it-in-your-ui"
        },
        {
          "title": "Set it up",
          "anchor": "set-it-up"
        },
        {
          "title": "Benchmarks",
          "anchor": "benchmarks"
        },
        {
          "title": "Example provider run (2026-06-09, US client, real API calls)",
          "anchor": "example-provider-run-2026-06-09-us-client-real-api-calls"
        },
        {
          "title": "Get the code",
          "anchor": "get-the-code"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# External Compute Providers\n\n<div style=\"display:flex;align-items:center;gap:1rem;flex-wrap:wrap;margin:1rem 0 1.5rem;\">\n  <span style=\"font-size:1.05rem;opacity:.7;\">Available providers:</span>\n  <span style=\"display:inline-flex;align-items:center;gap:.5rem;padding:.4rem .8rem;border:1px solid var(--docs-border,#2a2a2a);border-radius:10px;\">\n    <img src=\"/integrations/orgo.png\" alt=\"Orgo\" width=\"22\" height=\"20\" style=\"display:block;\" />\n    <strong>Orgo</strong>\n    <span style=\"font-size:.8r"
    },
    {
      "slug": "integrations/preview-tokens",
      "path": "/docs/integrations/preview-tokens",
      "url": "https://miosa.ai/docs/integrations/preview-tokens",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/integrations/preview-tokens",
      "title": "Preview Tokens",
      "description": "Mint short-lived server-side tokens to embed sandbox previews in iframes without exposing your API key to the browser.",
      "source": "src/routes/docs/integrations/preview-tokens/+page.md",
      "headings": [
        {
          "title": "Why preview tokens exist",
          "anchor": "why-preview-tokens-exist"
        },
        {
          "title": "Token format",
          "anchor": "token-format"
        },
        {
          "title": "TTL strategy",
          "anchor": "ttl-strategy"
        },
        {
          "title": "Server-side mint flow",
          "anchor": "server-side-mint-flow"
        },
        {
          "title": "Iframe attachment",
          "anchor": "iframe-attachment"
        },
        {
          "title": "Token refresh",
          "anchor": "token-refresh"
        },
        {
          "title": "Permission scoping",
          "anchor": "permission-scoping"
        },
        {
          "title": "Early revocation",
          "anchor": "early-revocation"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Preview tokens\n\nA preview token (`mp_...`) is a short-lived credential that grants read-only access to a specific sandbox preview. You mint it server-side and pass it to the browser. The browser uses it as the `src` of an `<iframe>`. Your `msk_*` API key never leaves your server.\n\n---\n\n## Why preview tokens exist\n\nSandbox previews are live HTTP services running inside isolated VMs. To embed one in your product UI, the browser needs to make an authenticated request to the MIOSA preview proxy.\n\n"
    },
    {
      "slug": "integrations/webhooks",
      "path": "/docs/integrations/webhooks",
      "url": "https://miosa.ai/docs/integrations/webhooks",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/integrations/webhooks",
      "title": "Webhooks",
      "description": "Subscribe to sandbox and deployment lifecycle events, verify HMAC-SHA256 signatures, handle retries, and test locally.",
      "source": "src/routes/docs/integrations/webhooks/+page.md",
      "headings": [
        {
          "title": "Event taxonomy",
          "anchor": "event-taxonomy"
        },
        {
          "title": "Sandbox events",
          "anchor": "sandbox-events"
        },
        {
          "title": "Deployment events",
          "anchor": "deployment-events"
        },
        {
          "title": "Payload structure",
          "anchor": "payload-structure"
        },
        {
          "title": "HMAC-SHA256 signature verification",
          "anchor": "hmac-sha256-signature-verification"
        },
        {
          "title": "Idempotency",
          "anchor": "idempotency"
        },
        {
          "title": "Retry policy",
          "anchor": "retry-policy"
        },
        {
          "title": "Register a webhook",
          "anchor": "register-a-webhook"
        },
        {
          "title": "Local testing",
          "anchor": "local-testing"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Webhooks\n\nMIOSA sends HTTP `POST` requests to your endpoint whenever a sandbox or deployment changes state. Use webhooks to update your database, notify users, trigger downstream actions, or bill for compute.\n\n---\n\n## Event taxonomy\n\n### Sandbox events\n\n| Event | Fires when |\n|---|---|\n| `sandbox.created` | The sandbox row is inserted. The VM may still be booting. |\n| `sandbox.running` | The sandbox is fully booted and ready. `external_user_id` is available. |\n| `sandbox.paused` | The sandbox "
    },
    {
      "slug": "integrations/whitelabel-saas",
      "path": "/docs/integrations/whitelabel-saas",
      "url": "https://miosa.ai/docs/integrations/whitelabel-saas",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/integrations/whitelabel-saas",
      "title": "White-Label SaaS  -  End-to-End Walkthrough",
      "description": "Build a product like OpenDesigns.ai on MIOSA. Per-user sandboxes, custom domains, iframe embeds, webhooks, usage billing, and quota controls  -  all from scratch to production.",
      "source": "src/routes/docs/integrations/whitelabel-saas/+page.md",
      "headings": [
        {
          "title": "Prerequisites",
          "anchor": "prerequisites"
        },
        {
          "title": "One-time setup",
          "anchor": "one-time-setup"
        },
        {
          "title": "Set branding",
          "anchor": "set-branding"
        },
        {
          "title": "Register a preview domain",
          "anchor": "register-a-preview-domain"
        },
        {
          "title": "Register a webhook",
          "anchor": "register-a-webhook"
        },
        {
          "title": "Per-user provisioning",
          "anchor": "per-user-provisioning"
        },
        {
          "title": "Pretty URLs",
          "anchor": "pretty-urls"
        },
        {
          "title": "Embed a preview in an iframe",
          "anchor": "embed-a-preview-in-an-iframe"
        },
        {
          "title": "Get notified: webhook subscription",
          "anchor": "get-notified-webhook-subscription"
        },
        {
          "title": "Customize after create",
          "anchor": "customize-after-create"
        },
        {
          "title": "Bill by user",
          "anchor": "bill-by-user"
        },
        {
          "title": "Per-user quotas",
          "anchor": "per-user-quotas"
        },
        {
          "title": "Branded failure pages",
          "anchor": "branded-failure-pages"
        },
        {
          "title": "Public sharing",
          "anchor": "public-sharing"
        },
        {
          "title": "End-user file tree, terminal, and run buttons",
          "anchor": "end-user-file-tree-terminal-and-run-buttons"
        },
        {
          "title": "File tree",
          "anchor": "file-tree"
        },
        {
          "title": "Terminal",
          "anchor": "terminal"
        },
        {
          "title": "Run button",
          "anchor": "run-button"
        },
        {
          "title": "Teardown on cancellation",
          "anchor": "teardown-on-cancellation"
        },
        {
          "title": "End-to-end checklist",
          "anchor": "end-to-end-checklist"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# White-label SaaS  -  end-to-end walkthrough\n\nThis walkthrough builds **OpenDesigns**, a design-tool SaaS where each customer gets an isolated workspace. OpenDesigns's end users never see the MIOSA brand: the domain is `opendesigns.ai`, the product name is \"OpenDesigns Workspaces\", and the failure pages show the OpenDesigns logo.\n\nEverything here maps directly to working code in [`examples/whitelabel-saas`](https://github.com/Miosa-osa/miosa/tree/main/examples/whitelabel-saas).\n\n---\n\n## Prerequ"
    },
    {
      "slug": "known-limitations",
      "path": "/docs/known-limitations",
      "url": "https://miosa.ai/docs/known-limitations",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/known-limitations",
      "title": "Known Limitations",
      "description": "An honest list of what doesn't work yet, what's in progress, and what's intentionally out of scope. Updated continuously.",
      "source": "src/routes/docs/known-limitations/+page.md",
      "headings": [
        {
          "title": "Sandboxes <Tag variant=\"neutral\">Public V1</Tag>",
          "anchor": "sandboxes-public-v1"
        },
        {
          "title": "Deployments <Tag variant=\"neutral\">Phase 3/4 complete; dynamic runtime in hardening</Tag>",
          "anchor": "deployments-phase-34-complete-dynamic-runtime-in-hardening"
        },
        {
          "title": "Data Services",
          "anchor": "data-services"
        },
        {
          "title": "Computers (Desktop) <Tag variant=\"neutral\">GA</Tag>",
          "anchor": "computers-desktop-ga"
        },
        {
          "title": "Computer-Use API",
          "anchor": "computer-use-api"
        },
        {
          "title": "SDKs",
          "anchor": "sdks"
        },
        {
          "title": "API",
          "anchor": "api"
        },
        {
          "title": "Pricing and Billing",
          "anchor": "pricing-and-billing"
        },
        {
          "title": "Observability",
          "anchor": "observability"
        },
        {
          "title": "What We Are Explicitly Not Building",
          "anchor": "what-we-are-explicitly-not-building"
        },
        {
          "title": "See Also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Known Limitations\n\nWe document what doesn't work, on purpose. If you hit something here, it isn't a bug in your code. It is a known gap. Each item notes the status or planned ship window.\n\nLast updated: 2026-07-19. We update this page on every release.\n\n## Sandboxes Public V1\n\n- **Availability is catalog-driven**. A named size, including `xs`, can be selected only when the template catalog and tenant policy admit it. A published contract is not a guarantee of immediate capacity in every enviro"
    },
    {
      "slug": "learn",
      "path": "/docs/learn",
      "url": "https://miosa.ai/docs/learn",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/learn",
      "title": "Learning Paths",
      "description": "Goal-based paths for learning MIOSA through complete, verifiable workflows instead of isolated reference pages.",
      "source": "src/routes/docs/learn/+page.md",
      "headings": [
        {
          "title": "Choose your goal",
          "anchor": "choose-your-goal"
        },
        {
          "title": "The shared learning loop",
          "anchor": "the-shared-learning-loop"
        },
        {
          "title": "Path 1: Deploy your first production app",
          "anchor": "path-1-deploy-your-first-production-app"
        },
        {
          "title": "Path 2: Build an agent product",
          "anchor": "path-2-build-an-agent-product"
        },
        {
          "title": "Path 3: Automate a real desktop",
          "anchor": "path-3-automate-a-real-desktop"
        },
        {
          "title": "Path 4: Build a white-label platform",
          "anchor": "path-4-build-a-white-label-platform"
        },
        {
          "title": "Choose the right compute product",
          "anchor": "choose-the-right-compute-product"
        },
        {
          "title": "Keep the references nearby",
          "anchor": "keep-the-references-nearby"
        }
      ],
      "content_excerpt": "# Learning Paths\n\nChoose what you want to accomplish, then follow one path from setup to verified result.\n\nEach path connects the detailed guides, examples, and API references already in the documentation.\nIt gives that material a practical order and a clear finish line without replacing it.\n\nStart with **Deploy your first production app**.\nIt teaches the resource model that the agent, desktop, and white-label paths build upon.\n\n## Choose your goal\n\n  \n    Build a Next.js app in a Sandbox, previ"
    },
    {
      "slug": "learn/first-production-app",
      "path": "/docs/learn/first-production-app",
      "url": "https://miosa.ai/docs/learn/first-production-app",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/learn/first-production-app",
      "title": "Build and deploy a Next.js app",
      "description": "Build a small Next.js app in a Sandbox, preview it, publish it through App Engine, prove it is live, and connect a custom domain.",
      "source": "src/routes/docs/learn/first-production-app/+page.md",
      "headings": [
        {
          "title": "What you will create",
          "anchor": "what-you-will-create"
        },
        {
          "title": "Before you start",
          "anchor": "before-you-start"
        },
        {
          "title": "Step 1: Create the Sandbox",
          "anchor": "step-1-create-the-sandbox"
        },
        {
          "title": "Step 2: Create the Next.js application",
          "anchor": "step-2-create-the-nextjs-application"
        },
        {
          "title": "Step 3: Start and preview the application",
          "anchor": "step-3-start-and-preview-the-application"
        },
        {
          "title": "Step 4: Publish through App Engine",
          "anchor": "step-4-publish-through-app-engine"
        },
        {
          "title": "Step 5: Prove production",
          "anchor": "step-5-prove-production"
        },
        {
          "title": "Step 6: Connect a custom domain",
          "anchor": "step-6-connect-a-custom-domain"
        },
        {
          "title": "Step 7: Publish an update safely",
          "anchor": "step-7-publish-an-update-safely"
        },
        {
          "title": "Step 8: Understand rollback before you need it",
          "anchor": "step-8-understand-rollback-before-you-need-it"
        },
        {
          "title": "Common failures and recovery",
          "anchor": "common-failures-and-recovery"
        },
        {
          "title": "Completion checklist",
          "anchor": "completion-checklist"
        },
        {
          "title": "Continue from here",
          "anchor": "continue-from-here"
        }
      ],
      "content_excerpt": "# Build and deploy a Next.js app\n\nThis tutorial takes a small Next.js application from an empty Sandbox to a verified production URL.\n\nYou will build in a Sandbox, inspect a temporary Preview, publish an immutable Version, verify the stable Deployment URL, and optionally connect `app.example.com`.\n\nPublishing does not destroy or convert the Sandbox.\nThe Sandbox remains a development environment, while the Release and Deployment become independent production resources.\n\n## What you will create\n\n|"
    },
    {
      "slug": "mcp",
      "path": "/docs/mcp",
      "url": "https://miosa.ai/docs/mcp",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/mcp",
      "title": "MCP Server",
      "description": "Connect Claude Code, Cursor, Gemini CLI, OpenCode, or any MCP-aware AI client to MIOSA. One-command install, browser-based auth, sandbox + desktop + deploy tools.",
      "source": "src/routes/docs/mcp/+page.md",
      "headings": [
        {
          "title": "One-command install (recommended)",
          "anchor": "one-command-install-recommended"
        },
        {
          "title": "Install for other clients",
          "anchor": "install-for-other-clients"
        },
        {
          "title": "What you get - the capability-scoped tool catalog",
          "anchor": "what-you-get-the-capability-scoped-tool-catalog"
        },
        {
          "title": "Drop-in skills for Claude Code",
          "anchor": "drop-in-skills-for-claude-code"
        },
        {
          "title": "Lifecycle",
          "anchor": "lifecycle"
        },
        {
          "title": "Tips",
          "anchor": "tips"
        },
        {
          "title": "Workflow",
          "anchor": "workflow"
        },
        {
          "title": "Tips",
          "anchor": "tips"
        },
        {
          "title": "Workflow",
          "anchor": "workflow"
        },
        {
          "title": "Tips",
          "anchor": "tips"
        },
        {
          "title": "Drop this into a fresh agent",
          "anchor": "drop-this-into-a-fresh-agent"
        },
        {
          "title": "Auth model",
          "anchor": "auth-model"
        },
        {
          "title": "Troubleshooting",
          "anchor": "troubleshooting"
        },
        {
          "title": "Hosted HTTP vs local stdio",
          "anchor": "hosted-http-vs-local-stdio"
        }
      ],
      "content_excerpt": "# MCP Server\n\nMIOSA ships a public **Model Context Protocol** server at\n`https://api.miosa.ai/api/v1/mcp`. Any MCP-aware AI client  -  Claude Code,\nCursor, Gemini CLI, OpenCode, Hermes, custom GPTs  -  can connect with a single\ncommand and immediately gain MIOSA's sandbox + desktop + deploy toolbelt.\n\n```bash\nnpx -y @miosa/cli mcp install\n```\n\nThat's it. Browser opens, you log in to MIOSA, and Claude Code is wired.\n\n---\n\n## One-command install (recommended)\n\n```bash\nnpx -y @miosa/cli mcp install"
    },
    {
      "slug": "operations/recovery",
      "path": "/docs/operations/recovery",
      "url": "https://miosa.ai/docs/operations/recovery",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/operations/recovery",
      "title": "Recovery Playbooks",
      "description": "Symptom-first recovery procedures for deployments, domains, TLS, App Engine hosts, sandboxes, and production rollback.",
      "source": "src/routes/docs/operations/recovery/+page.md",
      "headings": [
        {
          "title": "First five minutes",
          "anchor": "first-five-minutes"
        },
        {
          "title": "Deployment is down",
          "anchor": "deployment-is-down"
        },
        {
          "title": "Domain remains pending",
          "anchor": "domain-remains-pending"
        },
        {
          "title": "TLS is not active",
          "anchor": "tls-is-not-active"
        },
        {
          "title": "App Engine host is unhealthy",
          "anchor": "app-engine-host-is-unhealthy"
        },
        {
          "title": "Sandbox preview fails",
          "anchor": "sandbox-preview-fails"
        },
        {
          "title": "Escalation evidence",
          "anchor": "escalation-evidence"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Recovery Playbooks\n\nUse these playbooks when a customer-visible workflow is unhealthy.\n\nDiagnose before mutating anything, preserve the last known-good version, and make one bounded recovery change at a time.\n\n## First five minutes\n\n1. Resolve the exact Organization, Workspace, Project, and affected resource.\n2. Record the public URL, deployment ID, active version ID, and current health state.\n3. Test the public route from outside the runtime.\n4. Separate build, runtime, route, DNS, and TLS fa"
    },
    {
      "slug": "platform/agent-credit-metering",
      "path": "/docs/platform/agent-credit-metering",
      "url": "https://miosa.ai/docs/platform/agent-credit-metering",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/platform/agent-credit-metering",
      "title": "Agent credit metering",
      "description": "How to meter credits for MIOSA agent runs, model usage, devices, tools, storage, and deployments.",
      "source": "src/routes/docs/platform/agent-credit-metering/+page.md",
      "headings": [
        {
          "title": "Metered surfaces",
          "anchor": "metered-surfaces"
        },
        {
          "title": "Ledger shape",
          "anchor": "ledger-shape"
        },
        {
          "title": "Run-level cost model",
          "anchor": "run-level-cost-model"
        },
        {
          "title": "Simple examples",
          "anchor": "simple-examples"
        },
        {
          "title": "One-shot health check",
          "anchor": "one-shot-health-check"
        },
        {
          "title": "Sandbox app generation",
          "anchor": "sandbox-app-generation"
        },
        {
          "title": "Browser automation",
          "anchor": "browser-automation"
        },
        {
          "title": "Agent-company workflow",
          "anchor": "agent-company-workflow"
        },
        {
          "title": "Budget policies",
          "anchor": "budget-policies"
        },
        {
          "title": "Credits in white-label products",
          "anchor": "credits-in-white-label-products"
        },
        {
          "title": "Credit events",
          "anchor": "credit-events"
        },
        {
          "title": "Failure handling",
          "anchor": "failure-handling"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Agent credit metering\n\nCredits are the business model for agent work on MIOSA. A user does not buy\n\"a sandbox\" or \"a model call\" in isolation. They buy credits that power agents\ndoing useful work on devices.\n\n```text\ncredits = model usage + device runtime + tools + storage + deployments\n```\n\nUse this page when building billing, quotas, usage pages, workspace budgets,\nor white-label credit systems.\n\n---\n\n## Metered surfaces\n\n| Surface | Examples | When charged |\n|---|---|---|\n| Model/runtime | "
    },
    {
      "slug": "platform/api-keys",
      "path": "/docs/platform/api-keys",
      "url": "https://miosa.ai/docs/platform/api-keys",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/platform/api-keys",
      "title": "API Keys",
      "description": "User and platform API keys for personal tools, backend automation, and scoped MIOSA API access.",
      "source": "src/routes/docs/platform/api-keys/+page.md",
      "headings": [
        {
          "title": "Create a key",
          "anchor": "create-a-key"
        },
        {
          "title": "Key families",
          "anchor": "key-families"
        },
        {
          "title": "Scopes",
          "anchor": "scopes"
        },
        {
          "title": "Rotation",
          "anchor": "rotation"
        },
        {
          "title": "4. Delete the old key",
          "anchor": "4-delete-the-old-key"
        },
        {
          "title": "Rate limits",
          "anchor": "rate-limits"
        },
        {
          "title": "Audit",
          "anchor": "audit"
        },
        {
          "title": "Browser keys (no)",
          "anchor": "browser-keys-no"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "An **API key** authenticates a person or backend service to MIOSA.\nUser keys are personal credentials.\nPlatform keys are tenant automation credentials and can optionally be restricted to one workspace.\n\n## Create a key\n\nFrom the dashboard: **Workspace → Settings → API Keys → New key**. Or via API:\n```http\nPOST /api/v1/api-keys\n```\n\n```typescript\nconst key = await miosa.apiKeys.create({\n  name: \"ClinicIQ backend prod\",\n  key_type: \"platform\",\n  workspace_id: workspaceId,\n  scopes: [\"deployments:w"
    },
    {
      "slug": "platform/attribution",
      "path": "/docs/platform/attribution",
      "url": "https://miosa.ai/docs/platform/attribution",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/platform/attribution",
      "title": "Resource Ownership and Attribution",
      "description": "Scope resources to MIOSA workspaces and projects while preserving your own workspace / user / project IDs for billing and reconciliation.",
      "source": "src/routes/docs/platform/attribution/+page.md",
      "headings": [
        {
          "title": "Ownership fields",
          "anchor": "ownership-fields"
        },
        {
          "title": "Attribution fields",
          "anchor": "attribution-fields"
        },
        {
          "title": "How it flows",
          "anchor": "how-it-flows"
        },
        {
          "title": "On every create",
          "anchor": "on-every-create"
        },
        {
          "title": "Filter by ownership or attribution",
          "anchor": "filter-by-ownership-or-attribution"
        },
        {
          "title": "Inheritance",
          "anchor": "inheritance"
        },
        {
          "title": "Authorization vs ownership vs attribution",
          "anchor": "authorization-vs-ownership-vs-attribution"
        },
        {
          "title": "Storage and indexing",
          "anchor": "storage-and-indexing"
        },
        {
          "title": "What to use vs leave null",
          "anchor": "what-to-use-vs-leave-null"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "Resource ownership is how MIOSA decides where a resource lives. External attribution is how your platform maps that resource back to your own database.\n\n- `workspace_id` and `project_id` are canonical MIOSA ownership. They affect routing, permissions, dashboard grouping, usage, and where resources appear.\n- `external_workspace_id`, `external_user_id`, and `external_project_id` are opaque strings from your platform. They are copied to usage, audit, and child resources for reconciliation.\n\n## Owne"
    },
    {
      "slug": "platform/browser-tokens",
      "path": "/docs/platform/browser-tokens",
      "url": "https://miosa.ai/docs/platform/browser-tokens",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/platform/browser-tokens",
      "title": "Browser Tokens",
      "description": "Short-lived scoped credentials your backend mints for end-user-facing access. Never expose `msk_*` to the browser.",
      "source": "src/routes/docs/platform/browser-tokens/+page.md",
      "headings": [
        {
          "title": "The mint flow",
          "anchor": "the-mint-flow"
        },
        {
          "title": "The pattern",
          "anchor": "the-pattern"
        },
        {
          "title": "Preview share tokens (the main one)",
          "anchor": "preview-share-tokens-the-main-one"
        },
        {
          "title": "Token formats",
          "anchor": "token-formats"
        },
        {
          "title": "Lifetime and expiry",
          "anchor": "lifetime-and-expiry"
        },
        {
          "title": "Re-minting and revoking",
          "anchor": "re-minting-and-revoking"
        },
        {
          "title": "CSP and embedding",
          "anchor": "csp-and-embedding"
        },
        {
          "title": "Audit",
          "anchor": "audit"
        },
        {
          "title": "What browser tokens cannot do",
          "anchor": "what-browser-tokens-cannot-do"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "When your end-user's browser needs direct MIOSA access  -  previewing a sandbox, opening a terminal, uploading a file  -  mint a short-lived browser token server-side and hand only that to the browser. The workspace API key (`msk_*`) never leaves your backend.\n\n## The mint flow\n\nDiagram:\nsequenceDiagram\n    participant BR as Browser\n    participant BE as Your Backend\n    participant MI as MIOSA\n\n    BR->>BE: show preview\n    BE->>MI: POST /previews/:id/share (msk_* key)\n    MI-->>BE: preview_tok"
    },
    {
      "slug": "platform/byoc",
      "path": "/docs/platform/byoc",
      "url": "https://miosa.ai/docs/platform/byoc",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/platform/byoc",
      "title": "Customer infrastructure",
      "description": "Run MIOSA workloads on managed compute, connected machines, or governed capacity inside a customer AWS or Google Cloud environment.",
      "source": "src/routes/docs/platform/byoc/+page.md",
      "headings": [
        {
          "title": "Choose an infrastructure model",
          "anchor": "choose-an-infrastructure-model"
        },
        {
          "title": "Control plane and customer cloud",
          "anchor": "control-plane-and-customer-cloud"
        },
        {
          "title": "Provider foundations",
          "anchor": "provider-foundations"
        },
        {
          "title": "Activation sequence",
          "anchor": "activation-sequence"
        },
        {
          "title": "Shared responsibility",
          "anchor": "shared-responsibility"
        },
        {
          "title": "Product contract",
          "anchor": "product-contract"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Customer infrastructure\n\nMIOSA can orchestrate products across infrastructure operated by MIOSA or controlled by the customer.\n\nThe product keeps one resource model and control plane while placement determines where work executes.\n\nProvider accounts, regions, pools, host inventory, placement policy, and verification receipts belong to the organization.\n\nWorkspace-specific environment variables, secrets, projects, and workload defaults remain workspace scoped and are applied only after organiza"
    },
    {
      "slug": "platform/custom-domains",
      "path": "/docs/platform/custom-domains",
      "url": "https://miosa.ai/docs/platform/custom-domains",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/platform/custom-domains",
      "title": "Custom Preview Domains",
      "description": "Serve sandbox previews, production apps, and exact resources on your own domains through MIOSA-managed routing.",
      "source": "src/routes/docs/platform/custom-domains/+page.md",
      "headings": [
        {
          "title": "Current domain layers",
          "anchor": "current-domain-layers"
        },
        {
          "title": "Add this CNAME record at your DNS provider",
          "anchor": "add-this-cname-record-at-your-dns-provider"
        },
        {
          "title": "How it works",
          "anchor": "how-it-works"
        },
        {
          "title": "Troubleshooting",
          "anchor": "troubleshooting"
        },
        {
          "title": "Disconnecting",
          "anchor": "disconnecting"
        },
        {
          "title": "Optional  -  explicit registration via Settings → Domains",
          "anchor": "optional-explicit-registration-via-settings-domains"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "This page is the white-label preview-domain entry point.\nThe canonical routing and production-domain contract lives in [Deployment Domains](/docs/deploy/domains/).\n\nCustom domains are layered.\nDo not treat one wildcard as the whole product.\nSandbox previews, production deployments, App Engine apps, computers, and exact customer hostnames each have their own routing rules.\n\nFor the full current model, start with [Deployment Domains](/docs/deploy/domains/) and [White-label setup](/docs/platform/wh"
    },
    {
      "slug": "platform/overview",
      "path": "/docs/platform/overview",
      "url": "https://miosa.ai/docs/platform/overview",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/platform/overview",
      "title": "White-label platform architecture",
      "description": "Build your own AI app builder on top of MIOSA with organization, workspace, project, resource ownership, custom domains, and short-lived browser tokens.",
      "source": "src/routes/docs/platform/overview/+page.md",
      "headings": [
        {
          "title": "What is the white-label model?",
          "anchor": "what-is-the-white-label-model"
        },
        {
          "title": "When to use it",
          "anchor": "when-to-use-it"
        },
        {
          "title": "Quick example",
          "anchor": "quick-example"
        },
        {
          "title": "How it fits together",
          "anchor": "how-it-fits-together"
        },
        {
          "title": "Ownership and attribution fields",
          "anchor": "ownership-and-attribution-fields"
        },
        {
          "title": "Next",
          "anchor": "next"
        },
        {
          "title": "Reference integration",
          "anchor": "reference-integration"
        }
      ],
      "content_excerpt": "# White-label platform architecture\n\nThis section is for **builders**  -  platforms that embed MIOSA so their customers can build, preview, and deploy apps inside the builder's own product (AI app builders, white-label SaaS).\n\nIf you're a developer using MIOSA to ship your own app, read [Quickstart](/docs/quickstart/) Track A instead.\n\n## What is the white-label model?\n\nMIOSA lets one organization act as a platform for many downstream customers without giving those customers MIOSA accounts. Your"
    },
    {
      "slug": "platform/usage-and-billing",
      "path": "/docs/platform/usage-and-billing",
      "url": "https://miosa.ai/docs/platform/usage-and-billing",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/platform/usage-and-billing",
      "title": "Usage & Billing",
      "description": "Track MIOSA usage per workspace, per project, per external customer, and per user. Chargeback to your customers.",
      "source": "src/routes/docs/platform/usage-and-billing/+page.md",
      "headings": [
        {
          "title": "What's metered",
          "anchor": "whats-metered"
        },
        {
          "title": "Usage report API",
          "anchor": "usage-report-api"
        },
        {
          "title": "Audit log",
          "anchor": "audit-log"
        },
        {
          "title": "Quotas and limits",
          "anchor": "quotas-and-limits"
        },
        {
          "title": "Pricing",
          "anchor": "pricing"
        },
        {
          "title": "Billing tenancy",
          "anchor": "billing-tenancy"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "If you're a platform reselling MIOSA capacity, you need to attribute MIOSA costs back to your own customers. MIOSA emits usage events with [resource ownership and external attribution](/docs/platform/attribution/) on every billable action; you query them, group, and chargeback in your own currency / margin model.\n\nTenant-scoped usage rollup, session usage, summary, workspace usage, and audit-log endpoints are live.\nThe exact dimensions available in a response depend on the resource and metering "
    },
    {
      "slug": "platform/white-label",
      "path": "/docs/platform/white-label",
      "url": "https://miosa.ai/docs/platform/white-label",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/platform/white-label",
      "title": "Branding and domain setup",
      "description": "Configure organization slug, workspace/project ownership, preview domains, deployment domains, branding, and resource attribution.",
      "source": "src/routes/docs/platform/white-label/+page.md",
      "headings": [
        {
          "title": "Setup flow",
          "anchor": "setup-flow"
        },
        {
          "title": "1. Organization identity",
          "anchor": "1-organization-identity"
        },
        {
          "title": "2. Workspaces and projects",
          "anchor": "2-workspaces-and-projects"
        },
        {
          "title": "3. URL layers",
          "anchor": "3-url-layers"
        },
        {
          "title": "4. Organization preview domain",
          "anchor": "4-organization-preview-domain"
        },
        {
          "title": "5. Deployment domain",
          "anchor": "5-deployment-domain"
        },
        {
          "title": "6. Resource custom domains",
          "anchor": "6-resource-custom-domains"
        },
        {
          "title": "7. Domain precedence",
          "anchor": "7-domain-precedence"
        },
        {
          "title": "8. Branding",
          "anchor": "8-branding"
        },
        {
          "title": "9. Browser tokens",
          "anchor": "9-browser-tokens"
        },
        {
          "title": "Complete setup checklist",
          "anchor": "complete-setup-checklist"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Branding and domain setup\n\nMIOSA can run behind your product and your customers' domains. The important order is: set the organization identity first, create workspaces/projects for downstream customers, configure preview and deployment domains separately, then attach exact custom domains where a customer needs their own hostname.\n\n---\n\n## Setup flow\nDiagram:\nflowchart TD\n  A[Set organization name] --> B[Organization slug is created once]\n  B --> C[Create workspaces for customers]\n  C --> D[Cr"
    },
    {
      "slug": "projects",
      "path": "/docs/projects",
      "url": "https://miosa.ai/docs/projects",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/projects",
      "title": "Projects",
      "description": "Understand how Projects group development, production, data, domains, ownership, and usage without becoming a runtime themselves.",
      "source": "src/routes/docs/projects/+page.md",
      "headings": [
        {
          "title": "Where a Project fits",
          "anchor": "where-a-project-fits"
        },
        {
          "title": "Choose the right boundary",
          "anchor": "choose-the-right-boundary"
        },
        {
          "title": "Recommended lifecycle",
          "anchor": "recommended-lifecycle"
        },
        {
          "title": "Domain inheritance",
          "anchor": "domain-inheritance"
        },
        {
          "title": "External platform mapping",
          "anchor": "external-platform-mapping"
        },
        {
          "title": "Operating checklist",
          "anchor": "operating-checklist"
        },
        {
          "title": "Common mistakes",
          "anchor": "common-mistakes"
        },
        {
          "title": "Next steps",
          "anchor": "next-steps"
        }
      ],
      "content_excerpt": "# Projects\n\nA **Project** is the durable product boundary inside one Workspace.\n\nIt groups the resources for one application or customer deliverable, but it does not run code itself.\n\nUse one Project when the resources should share ownership, attribution, lifecycle visibility, and default domain settings.\n\n## Where a Project fits\n\nDiagram:\nflowchart TD\n  O[\"Organization<br/>billing and policy\"] --> W[\"Workspace<br/>team or customer boundary\"]\n  W --> P[\"Project<br/>one product\"]\n  P --> S[\"Sandb"
    },
    {
      "slug": "quickstart",
      "path": "/docs/quickstart",
      "url": "https://miosa.ai/docs/quickstart",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/quickstart",
      "title": "Quickstart",
      "description": "A hands-on tour of MIOSA  -  create a sandbox, write code, preview it live, publish to production, and prove the deployment is actually running.",
      "source": "src/routes/docs/quickstart/+page.md",
      "headings": [
        {
          "title": "Prerequisites",
          "anchor": "prerequisites"
        },
        {
          "title": "2. A workspace API key: Dashboard → Settings → API Keys → New key. It starts with msk. Export it:",
          "anchor": "2-a-workspace-api-key-dashboard-settings-api-keys-new-key-it-starts-with-msk-export-it"
        },
        {
          "title": "3. SDK or tooling installed for your language",
          "anchor": "3-sdk-or-tooling-installed-for-your-language"
        },
        {
          "title": "Track 1: Sandbox to deployment",
          "anchor": "track-1-sandbox-to-deployment"
        },
        {
          "title": "Step 1  -  Create a sandbox.",
          "anchor": "step-1-create-a-sandbox"
        },
        {
          "title": "Step 2  -  Write a small static site into /workspace.",
          "anchor": "step-2-write-a-small-static-site-into-workspace"
        },
        {
          "title": "Step 3  -  Start a dev server so you can preview it.",
          "anchor": "step-3-start-a-dev-server-so-you-can-preview-it"
        },
        {
          "title": "Step 4  -  Create a preview and open it.",
          "anchor": "step-4-create-a-preview-and-open-it"
        },
        {
          "title": "Step 5  -  Publish to production.",
          "anchor": "step-5-publish-to-production"
        },
        {
          "title": "Step 6  -  Prove the deployment.",
          "anchor": "step-6-prove-the-deployment"
        },
        {
          "title": "Step 7  -  Make a change and republish.",
          "anchor": "step-7-make-a-change-and-republish"
        },
        {
          "title": "Step 8  -  (Optional) Attach a custom domain.",
          "anchor": "step-8-optional-attach-a-custom-domain"
        },
        {
          "title": "Step 9  -  Clean up.",
          "anchor": "step-9-clean-up"
        },
        {
          "title": "What you just did",
          "anchor": "what-you-just-did"
        },
        {
          "title": "Track 2: Agent-driven build",
          "anchor": "track-2-agent-driven-build"
        },
        {
          "title": "Step 1  -  Create a sandbox with external attribution.",
          "anchor": "step-1-create-a-sandbox-with-external-attribution"
        },
        {
          "title": "Step 2  -  Give your agent an exec tool.",
          "anchor": "step-2-give-your-agent-an-exec-tool"
        },
        {
          "title": "Step 3  -  Let the agent write files directly.",
          "anchor": "step-3-let-the-agent-write-files-directly"
        },
        {
          "title": "Step 4  -  Start the dev server, create a preview, stream it to your user.",
          "anchor": "step-4-start-the-dev-server-create-a-preview-stream-it-to-your-user"
        },
        {
          "title": "Step 5  -  Take a screenshot of a Computer (optional).",
          "anchor": "step-5-take-a-screenshot-of-a-computer-optional"
        },
        {
          "title": "Step 6  -  Publish what the agent built.",
          "anchor": "step-6-publish-what-the-agent-built"
        },
        {
          "title": "Step 7  -  Filter all sandboxes for this customer.",
          "anchor": "step-7-filter-all-sandboxes-for-this-customer"
        },
        {
          "title": "Step 8  -  Clean up.",
          "anchor": "step-8-clean-up"
        },
        {
          "title": "What you just did",
          "anchor": "what-you-just-did"
        },
        {
          "title": "Track 3: App Engine",
          "anchor": "track-3-app-engine"
        },
        {
          "title": "Step 1  -  Ensure the workspace App Engine host.",
          "anchor": "step-1-ensure-the-workspace-app-engine-host"
        },
        {
          "title": "Step 2  -  Publish the sandbox to App Engine.",
          "anchor": "step-2-publish-the-sandbox-to-app-engine"
        },
        {
          "title": "Step 3  -  Prove the app container exists.",
          "anchor": "step-3-prove-the-app-container-exists"
        },
        {
          "title": "What you just did",
          "anchor": "what-you-just-did"
        },
        {
          "title": "What's next",
          "anchor": "whats-next"
        }
      ],
      "content_excerpt": "# Quickstart\n\nThree tracks.\nPick one, finish it, then read the other two.\n\n- **Track 1: Sandbox to deployment**  -  write a small site inside a sandbox, preview it live, publish to a permanent URL, and verify the URL returned by MIOSA.\n- **Track 2: Agent-driven build**  -  dispatch work into a sandbox from your backend, stream events, collect artifacts, and optionally use a Computer for browser tasks.\n- **Track 3: App Engine**  -  run many workspace apps as Docker containers on one always-on App"
    },
    {
      "slug": "sdks/egress",
      "path": "/docs/sdks/egress",
      "url": "https://miosa.ai/docs/sdks/egress",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/sdks/egress",
      "title": "Egress SDK reference",
      "description": "Every Secrets, Connect Accounts, Network Allowlist, and Audit Log SDK method across Python, TypeScript, Go, Java, and Elixir  -  side by side.",
      "source": "src/routes/docs/sdks/egress/+page.md",
      "headings": [
        {
          "title": "Secrets",
          "anchor": "secrets"
        },
        {
          "title": "secrets.set  -  Store a secret",
          "anchor": "secretsset-store-a-secret"
        },
        {
          "title": "secrets.list  -  List secrets on a sandbox",
          "anchor": "secretslist-list-secrets-on-a-sandbox"
        },
        {
          "title": "secrets.rotate  -  Update a secret's value",
          "anchor": "secretsrotate-update-a-secrets-value"
        },
        {
          "title": "secrets.delete  -  Remove a secret",
          "anchor": "secretsdelete-remove-a-secret"
        },
        {
          "title": "Connect Accounts (OAuth)",
          "anchor": "connect-accounts-oauth"
        },
        {
          "title": "secrets.connect  -  Initiate an OAuth flow",
          "anchor": "secretsconnect-initiate-an-oauth-flow"
        },
        {
          "title": "secrets.reauthorize  -  Re-run an OAuth flow for an existing connection",
          "anchor": "secretsreauthorize-re-run-an-oauth-flow-for-an-existing-connection"
        },
        {
          "title": "Network Allowlist",
          "anchor": "network-allowlist"
        },
        {
          "title": "network.allow  -  Add a host to the allowlist",
          "anchor": "networkallow-add-a-host-to-the-allowlist"
        },
        {
          "title": "network.deny  -  Explicitly block a host",
          "anchor": "networkdeny-explicitly-block-a-host"
        },
        {
          "title": "network.lockdown and network.observe",
          "anchor": "networklockdown-and-networkobserve"
        },
        {
          "title": "network.suggestions  -  Hosts observed in a time window",
          "anchor": "networksuggestions-hosts-observed-in-a-time-window"
        },
        {
          "title": "network.pending  -  Blocked hosts since lockdown",
          "anchor": "networkpending-blocked-hosts-since-lockdown"
        },
        {
          "title": "network.getpolicy  -  Inspect current mode and rules",
          "anchor": "networkgetpolicy-inspect-current-mode-and-rules"
        },
        {
          "title": "Audit Log",
          "anchor": "audit-log"
        },
        {
          "title": "audit.list  -  Query audit events",
          "anchor": "auditlist-query-audit-events"
        },
        {
          "title": "audit.tail  -  Live stream of audit events",
          "anchor": "audittail-live-stream-of-audit-events"
        },
        {
          "title": "audit.export  -  Export as CSV or JSON",
          "anchor": "auditexport-export-as-csv-or-json"
        },
        {
          "title": "Tenant-level methods",
          "anchor": "tenant-level-methods"
        },
        {
          "title": "client.secrets.set  -  Scope a secret at tenant or workspace level",
          "anchor": "clientsecretsset-scope-a-secret-at-tenant-or-workspace-level"
        },
        {
          "title": "client.audit.list  -  Tenant-wide audit query",
          "anchor": "clientauditlist-tenant-wide-audit-query"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# Egress SDK reference\n\nSide-by-side reference for every egress security method across all five MIOSA SDKs. Use this as a lookup table  -  for conceptual background, see the individual feature pages.\n\n---\n\n## Secrets\n\n### `secrets.set`  -  Store a secret\n\n```python\nsandbox.secrets.set(\n    name: str,\n    value: str,\n    expose_as_env: str,\n    scope: str = \"sandbox\",            # \"sandbox\" | \"user\" | \"external_user\" | \"external_workspace\" | \"tenant\"\n    external_user_id: str | None = None,\n    e"
    },
    {
      "slug": "sdks/elixir",
      "path": "/docs/sdks/elixir",
      "url": "https://miosa.ai/docs/sdks/elixir",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/sdks/elixir",
      "title": "Elixir SDK",
      "description": "Install, configure, and make your first request with the MIOSA Elixir SDK.",
      "source": "src/routes/docs/sdks/elixir/+page.md",
      "headings": [
        {
          "title": "Install",
          "anchor": "install"
        },
        {
          "title": "What's new in 1.2.0",
          "anchor": "whats-new-in-120"
        },
        {
          "title": "First request",
          "anchor": "first-request"
        },
        {
          "title": "Configure",
          "anchor": "configure"
        },
        {
          "title": "Authentication",
          "anchor": "authentication"
        },
        {
          "title": "Error handling",
          "anchor": "error-handling"
        },
        {
          "title": "Streaming events",
          "anchor": "streaming-events"
        },
        {
          "title": "Backend orchestration pattern",
          "anchor": "backend-orchestration-pattern"
        },
        {
          "title": "Phase 1-5 API Reference",
          "anchor": "phase-1-5-api-reference"
        },
        {
          "title": "Sandbox lifecycle (Phase 1)",
          "anchor": "sandbox-lifecycle-phase-1"
        },
        {
          "title": "Tenant preview domain (Phase 1)",
          "anchor": "tenant-preview-domain-phase-1"
        },
        {
          "title": "Tenant branding (Phase 1)",
          "anchor": "tenant-branding-phase-1"
        },
        {
          "title": "Webhooks (Phase 1)",
          "anchor": "webhooks-phase-1"
        },
        {
          "title": "Files advanced (Phase 2)",
          "anchor": "files-advanced-phase-2"
        },
        {
          "title": "Sandbox environment variables (Phase 2)",
          "anchor": "sandbox-environment-variables-phase-2"
        },
        {
          "title": "Processes (Phase 2)",
          "anchor": "processes-phase-2"
        },
        {
          "title": "Usage and quotas (Phase 3)",
          "anchor": "usage-and-quotas-phase-3"
        },
        {
          "title": "Audit log (Phase 3)",
          "anchor": "audit-log-phase-3"
        },
        {
          "title": "Sharing (Phase 4)",
          "anchor": "sharing-phase-4"
        },
        {
          "title": "White-label integrator flow",
          "anchor": "white-label-integrator-flow"
        },
        {
          "title": "Module reference",
          "anchor": "module-reference"
        },
        {
          "title": "Common patterns",
          "anchor": "common-patterns"
        },
        {
          "title": "Idempotency key",
          "anchor": "idempotency-key"
        },
        {
          "title": "Custom base URL (self-hosted)",
          "anchor": "custom-base-url-self-hosted"
        },
        {
          "title": "Webhook verification",
          "anchor": "webhook-verification"
        },
        {
          "title": "Where to next",
          "anchor": "where-to-next"
        }
      ],
      "content_excerpt": "The official Elixir SDK for MIOSA. Requires Elixir 1.15+ and OTP 25+. All functions return `{:ok, result}` or `{:error, %Miosa.Error{}}`.\n\n## Install\n\n```elixir\n# mix.exs\n{:miosa, \"~> 1.2\"}\n```\n\nThen run `mix deps.get`.\n\n  `miosa` is live on Hex.pm. Documentation: [hexdocs.pm/miosa](https://hexdocs.pm/miosa). The package requires Elixir 1.15+ and OTP 25+.\n\n## What's new in 1.2.0\n\n| Area | What shipped |\n|---|---|\n| Sandbox lifecycle | `Miosa.Sandboxes.update/3`, `Miosa.Sandboxes.preview_token/3`"
    },
    {
      "slug": "sdks/go",
      "path": "/docs/sdks/go",
      "url": "https://miosa.ai/docs/sdks/go",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/sdks/go",
      "title": "Go SDK",
      "description": "Install, configure, and make your first request with the MIOSA Go SDK.",
      "source": "src/routes/docs/sdks/go/+page.md",
      "headings": [
        {
          "title": "Install",
          "anchor": "install"
        },
        {
          "title": "What's new in v0.4.0",
          "anchor": "whats-new-in-v040"
        },
        {
          "title": "First request",
          "anchor": "first-request"
        },
        {
          "title": "Configure",
          "anchor": "configure"
        },
        {
          "title": "Authentication",
          "anchor": "authentication"
        },
        {
          "title": "Error handling",
          "anchor": "error-handling"
        },
        {
          "title": "Streaming events",
          "anchor": "streaming-events"
        },
        {
          "title": "Backend orchestration pattern",
          "anchor": "backend-orchestration-pattern"
        },
        {
          "title": "Phase 1-5 API Reference",
          "anchor": "phase-1-5-api-reference"
        },
        {
          "title": "Sandbox lifecycle (Phase 1)",
          "anchor": "sandbox-lifecycle-phase-1"
        },
        {
          "title": "Tenant preview domain (Phase 1)",
          "anchor": "tenant-preview-domain-phase-1"
        },
        {
          "title": "Tenant branding (Phase 1)",
          "anchor": "tenant-branding-phase-1"
        },
        {
          "title": "Webhooks (Phase 1)",
          "anchor": "webhooks-phase-1"
        },
        {
          "title": "Files advanced (Phase 2)",
          "anchor": "files-advanced-phase-2"
        },
        {
          "title": "Sandbox environment variables (Phase 2)",
          "anchor": "sandbox-environment-variables-phase-2"
        },
        {
          "title": "Processes (Phase 2)",
          "anchor": "processes-phase-2"
        },
        {
          "title": "Usage and quotas (Phase 3)",
          "anchor": "usage-and-quotas-phase-3"
        },
        {
          "title": "Audit log (Phase 3)",
          "anchor": "audit-log-phase-3"
        },
        {
          "title": "Sharing (Phase 4)",
          "anchor": "sharing-phase-4"
        },
        {
          "title": "White-label integrator flow",
          "anchor": "white-label-integrator-flow"
        },
        {
          "title": "Common patterns",
          "anchor": "common-patterns"
        },
        {
          "title": "Context-based timeouts",
          "anchor": "context-based-timeouts"
        },
        {
          "title": "Idempotency key",
          "anchor": "idempotency-key"
        },
        {
          "title": "Custom base URL (self-hosted)",
          "anchor": "custom-base-url-self-hosted"
        },
        {
          "title": "Resource coverage",
          "anchor": "resource-coverage"
        },
        {
          "title": "Where to next",
          "anchor": "where-to-next"
        }
      ],
      "content_excerpt": "The official Go SDK for MIOSA. Requires Go 1.21+. All methods accept a `context.Context` for cancellation and timeouts.\n\n## Install\n\n```bash\ngo get github.com/Miosa-osa/miosa-go@v0.4.0\n```\n\n  If goproxy has not indexed the release yet, use `GOPROXY=direct go get github.com/Miosa-osa/miosa-go@v0.4.0`.\n\n## What's new in v0.4.0\n\n| Area | What shipped |\n|---|---|\n| Sandbox lifecycle | `Sandboxes.Update()`, `Sandboxes.PreviewToken()`, `Sandboxes.Fork()` |\n| Tenant preview domain | `Tenant.GetPreviewD"
    },
    {
      "slug": "sdks/java",
      "path": "/docs/sdks/java",
      "url": "https://miosa.ai/docs/sdks/java",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/sdks/java",
      "title": "Java SDK",
      "description": "Install, configure, and make your first request with the MIOSA Java SDK.",
      "source": "src/routes/docs/sdks/java/+page.md",
      "headings": [
        {
          "title": "Install",
          "anchor": "install"
        },
        {
          "title": "What's new in 0.5.0",
          "anchor": "whats-new-in-050"
        },
        {
          "title": "First request",
          "anchor": "first-request"
        },
        {
          "title": "Configure",
          "anchor": "configure"
        },
        {
          "title": "Authentication",
          "anchor": "authentication"
        },
        {
          "title": "Error handling",
          "anchor": "error-handling"
        },
        {
          "title": "Streaming events",
          "anchor": "streaming-events"
        },
        {
          "title": "Backend orchestration pattern",
          "anchor": "backend-orchestration-pattern"
        },
        {
          "title": "Phase 1-5 API Reference",
          "anchor": "phase-1-5-api-reference"
        },
        {
          "title": "Sandbox lifecycle (Phase 1)",
          "anchor": "sandbox-lifecycle-phase-1"
        },
        {
          "title": "Tenant preview domain (Phase 1)",
          "anchor": "tenant-preview-domain-phase-1"
        },
        {
          "title": "Tenant branding (Phase 1)",
          "anchor": "tenant-branding-phase-1"
        },
        {
          "title": "Webhooks (Phase 1)",
          "anchor": "webhooks-phase-1"
        },
        {
          "title": "Files advanced (Phase 2)",
          "anchor": "files-advanced-phase-2"
        },
        {
          "title": "Sandbox environment variables (Phase 2)",
          "anchor": "sandbox-environment-variables-phase-2"
        },
        {
          "title": "Processes (Phase 2)",
          "anchor": "processes-phase-2"
        },
        {
          "title": "Usage and quotas (Phase 3)",
          "anchor": "usage-and-quotas-phase-3"
        },
        {
          "title": "Audit log (Phase 3)",
          "anchor": "audit-log-phase-3"
        },
        {
          "title": "Sharing (Phase 4)",
          "anchor": "sharing-phase-4"
        },
        {
          "title": "White-label integrator flow",
          "anchor": "white-label-integrator-flow"
        },
        {
          "title": "Common patterns",
          "anchor": "common-patterns"
        },
        {
          "title": "Async operations",
          "anchor": "async-operations"
        },
        {
          "title": "Idempotency key",
          "anchor": "idempotency-key"
        },
        {
          "title": "Pagination",
          "anchor": "pagination"
        },
        {
          "title": "Custom base URL (self-hosted)",
          "anchor": "custom-base-url-self-hosted"
        },
        {
          "title": "Webhook verification",
          "anchor": "webhook-verification"
        },
        {
          "title": "Resource coverage",
          "anchor": "resource-coverage"
        },
        {
          "title": "Where to next",
          "anchor": "where-to-next"
        }
      ],
      "content_excerpt": "The official Java SDK for MIOSA. Requires Java 11+. Blocking methods have async `*Async()` variants that return `CompletableFuture`.\n\n## Install\n\n```xml\n<dependency>\n  <groupId>ai.miosa</groupId>\n  <artifactId>miosa-sdk</artifactId>\n  <version>0.5.0</version>\n</dependency>\n```\n\n```groovy\nimplementation 'ai.miosa:miosa-sdk:0.5.0'\n```\n\n```kotlin\nimplementation(\"ai.miosa:miosa-sdk:0.5.0\")\n```\n\n```scala\nlibraryDependencies += \"ai.miosa\" % \"miosa-sdk\" % \"0.5.0\"\n```\n\n  Available on Maven Central as `a"
    },
    {
      "slug": "sdks/python",
      "path": "/docs/sdks/python",
      "url": "https://miosa.ai/docs/sdks/python",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/sdks/python",
      "title": "Python SDK",
      "description": "Install, configure, and make your first request with the MIOSA Python SDK.",
      "source": "src/routes/docs/sdks/python/+page.md",
      "headings": [
        {
          "title": "Install",
          "anchor": "install"
        },
        {
          "title": "Current capabilities",
          "anchor": "current-capabilities"
        },
        {
          "title": "First request",
          "anchor": "first-request"
        },
        {
          "title": "Configure",
          "anchor": "configure"
        },
        {
          "title": "Authentication",
          "anchor": "authentication"
        },
        {
          "title": "Async vs sync",
          "anchor": "async-vs-sync"
        },
        {
          "title": "Error handling",
          "anchor": "error-handling"
        },
        {
          "title": "Streaming events",
          "anchor": "streaming-events"
        },
        {
          "title": "Backend orchestration pattern",
          "anchor": "backend-orchestration-pattern"
        },
        {
          "title": "Phase 1-5 API Reference",
          "anchor": "phase-1-5-api-reference"
        },
        {
          "title": "Sandbox lifecycle (Phase 1)",
          "anchor": "sandbox-lifecycle-phase-1"
        },
        {
          "title": "Tenant preview domain (Phase 1)",
          "anchor": "tenant-preview-domain-phase-1"
        },
        {
          "title": "Tenant branding (Phase 1)",
          "anchor": "tenant-branding-phase-1"
        },
        {
          "title": "Webhooks (Phase 1)",
          "anchor": "webhooks-phase-1"
        },
        {
          "title": "Files advanced (Phase 2)",
          "anchor": "files-advanced-phase-2"
        },
        {
          "title": "Sandbox environment variables (Phase 2)",
          "anchor": "sandbox-environment-variables-phase-2"
        },
        {
          "title": "Processes (Phase 2)",
          "anchor": "processes-phase-2"
        },
        {
          "title": "Usage and quotas (Phase 3)",
          "anchor": "usage-and-quotas-phase-3"
        },
        {
          "title": "Audit log (Phase 3)",
          "anchor": "audit-log-phase-3"
        },
        {
          "title": "Tenant-wide event stream (Phase 3)",
          "anchor": "tenant-wide-event-stream-phase-3"
        },
        {
          "title": "Sharing (Phase 4)",
          "anchor": "sharing-phase-4"
        },
        {
          "title": "Resource Reference",
          "anchor": "resource-reference"
        },
        {
          "title": "Sandboxes",
          "anchor": "sandboxes"
        },
        {
          "title": "Computers",
          "anchor": "computers"
        },
        {
          "title": "Desktop",
          "anchor": "desktop"
        },
        {
          "title": "Workspaces",
          "anchor": "workspaces"
        },
        {
          "title": "Tenant / Settings / Regions",
          "anchor": "tenant-settings-regions"
        },
        {
          "title": "Dashboard / Analytics / Audit Log / Usage",
          "anchor": "dashboard-analytics-audit-log-usage"
        },
        {
          "title": "Webhooks",
          "anchor": "webhooks"
        },
        {
          "title": "API Keys",
          "anchor": "api-keys"
        },
        {
          "title": "Models / Completions / Embeddings",
          "anchor": "models-completions-embeddings"
        },
        {
          "title": "White-label integrator flow",
          "anchor": "white-label-integrator-flow"
        },
        {
          "title": "Common patterns",
          "anchor": "common-patterns"
        },
        {
          "title": "Workspace-scoped creation",
          "anchor": "workspace-scoped-creation"
        },
        {
          "title": "Idempotency key",
          "anchor": "idempotency-key"
        },
        {
          "title": "Pagination",
          "anchor": "pagination"
        },
        {
          "title": "Webhook verification",
          "anchor": "webhook-verification"
        },
        {
          "title": "Where to next",
          "anchor": "where-to-next"
        }
      ],
      "content_excerpt": "The official Python SDK for MIOSA. Supports Python 3.9+ and provides both synchronous (`Miosa`) and asynchronous (`AsyncMiosa`) clients.\n\n## Install\n\n```bash\npip install miosa\n```\n\n```bash\nuv pip install miosa\n```\n\n```bash\npoetry add miosa\n```\n\n## Current capabilities\n\n| Area | What shipped |\n|---|---|\n| App Engine proof | `client.deployments.prove()` now fails metadata-only App Engine deployments and verifies the `docker_deploy_app` row plus container route |\n| App Engine deployment data | Depl"
    },
    {
      "slug": "sdks/typescript",
      "path": "/docs/sdks/typescript",
      "url": "https://miosa.ai/docs/sdks/typescript",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/sdks/typescript",
      "title": "TypeScript SDK",
      "description": "Install, configure, and make your first request with the MIOSA TypeScript SDK.",
      "source": "src/routes/docs/sdks/typescript/+page.md",
      "headings": [
        {
          "title": "Install",
          "anchor": "install"
        },
        {
          "title": "Current capabilities",
          "anchor": "current-capabilities"
        },
        {
          "title": "First request",
          "anchor": "first-request"
        },
        {
          "title": "Configure",
          "anchor": "configure"
        },
        {
          "title": "Authentication",
          "anchor": "authentication"
        },
        {
          "title": "Error handling",
          "anchor": "error-handling"
        },
        {
          "title": "Streaming events",
          "anchor": "streaming-events"
        },
        {
          "title": "Backend orchestration pattern",
          "anchor": "backend-orchestration-pattern"
        },
        {
          "title": "Phase 1-5 API Reference",
          "anchor": "phase-1-5-api-reference"
        },
        {
          "title": "Sandbox lifecycle (Phase 1)",
          "anchor": "sandbox-lifecycle-phase-1"
        },
        {
          "title": "Tenant preview domain (Phase 1)",
          "anchor": "tenant-preview-domain-phase-1"
        },
        {
          "title": "Tenant branding (Phase 1)",
          "anchor": "tenant-branding-phase-1"
        },
        {
          "title": "Webhooks (Phase 1)",
          "anchor": "webhooks-phase-1"
        },
        {
          "title": "Files advanced (Phase 2)",
          "anchor": "files-advanced-phase-2"
        },
        {
          "title": "Sandbox environment variables (Phase 2)",
          "anchor": "sandbox-environment-variables-phase-2"
        },
        {
          "title": "Processes (Phase 2)",
          "anchor": "processes-phase-2"
        },
        {
          "title": "Usage and quotas (Phase 3)",
          "anchor": "usage-and-quotas-phase-3"
        },
        {
          "title": "Audit log (Phase 3)",
          "anchor": "audit-log-phase-3"
        },
        {
          "title": "Tenant-wide event stream (Phase 3)",
          "anchor": "tenant-wide-event-stream-phase-3"
        },
        {
          "title": "Sharing (Phase 4)",
          "anchor": "sharing-phase-4"
        },
        {
          "title": "White-label integrator flow",
          "anchor": "white-label-integrator-flow"
        },
        {
          "title": "Common patterns",
          "anchor": "common-patterns"
        },
        {
          "title": "Idempotency key",
          "anchor": "idempotency-key"
        },
        {
          "title": "Parallel sandbox creation",
          "anchor": "parallel-sandbox-creation"
        },
        {
          "title": "Pagination",
          "anchor": "pagination"
        },
        {
          "title": "Custom base URL (self-hosted)",
          "anchor": "custom-base-url-self-hosted"
        },
        {
          "title": "Webhook verification",
          "anchor": "webhook-verification"
        },
        {
          "title": "Resource coverage",
          "anchor": "resource-coverage"
        },
        {
          "title": "Where to next",
          "anchor": "where-to-next"
        }
      ],
      "content_excerpt": "The official TypeScript/JavaScript SDK for MIOSA. Works with Node.js 18+, Deno, Bun, and modern bundlers. Fully typed  -  no `any`.\n\n## Install\n\n```bash\nnpm install @miosa/sdk\n```\n\n```bash\npnpm add @miosa/sdk\n```\n\n```bash\nyarn add @miosa/sdk\n```\n\n```bash\nbun add @miosa/sdk\n```\n\n```typescript\n\n```\n\n## Current capabilities\n\n| Area | What shipped |\n|---|---|\n| App Engine proof | `client.deployments.prove()` now fails metadata-only App Engine deployments and verifies the `docker_deploy_app` row plus"
    },
    {
      "slug": "security",
      "path": "/docs/security",
      "url": "https://miosa.ai/docs/security",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/security",
      "title": "Security",
      "description": "Built-in credential vault, outbound network controls, and audit log on every MIOSA sandbox and computer. No setup. Free on all plans.",
      "source": "src/routes/docs/security/+page.md",
      "headings": [
        {
          "title": "Getting started in 60 seconds",
          "anchor": "getting-started-in-60-seconds"
        },
        {
          "title": "1. Add a credential",
          "anchor": "1-add-a-credential"
        },
        {
          "title": "2. Use your code unchanged",
          "anchor": "2-use-your-code-unchanged"
        },
        {
          "title": "3. (Optional) Check what you called + lock it down",
          "anchor": "3-optional-check-what-you-called-lock-it-down"
        },
        {
          "title": "Want to wire up GitHub / Google / Slack instead of pasting tokens?",
          "anchor": "want-to-wire-up-github-google-slack-instead-of-pasting-tokens"
        },
        {
          "title": "Building a white-label product on top of MIOSA?",
          "anchor": "building-a-white-label-product-on-top-of-miosa"
        },
        {
          "title": "Your code doesn't change",
          "anchor": "your-code-doesnt-change"
        },
        {
          "title": "Three guarantees",
          "anchor": "three-guarantees"
        },
        {
          "title": "Where to go next",
          "anchor": "where-to-go-next"
        },
        {
          "title": "Glossary",
          "anchor": "glossary"
        },
        {
          "title": "Real-world example  -  OpenAI customer-support agent in 5 minutes",
          "anchor": "real-world-example-openai-customer-support-agent-in-5-minutes"
        },
        {
          "title": "Troubleshooting",
          "anchor": "troubleshooting"
        }
      ],
      "content_excerpt": "# Security\n\nEvery MIOSA Sandbox and Computer ships with a built-in security boundary. **No setup. No add-on SKU. Free on every plan.**\n\nThree things you can use whenever you need them:\n\n| Feature | What it does | Page |\n|---|---|---|\n| **Secrets** | Store your API keys in MIOSA  -  sandboxes see opaque placeholders, the real values stay encrypted at rest | [Secrets](/docs/security/secrets) |\n| **Connect Accounts** | OAuth-based credential connection (GitHub, Google, Slack, …) instead of pasting "
    },
    {
      "slug": "security/audit-log",
      "path": "/docs/security/audit-log",
      "url": "https://miosa.ai/docs/security/audit-log",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/security/audit-log",
      "title": "Audit Log",
      "description": "Every outbound call your sandbox makes is logged. Live-tail, filter, export.",
      "source": "src/routes/docs/security/audit-log/+page.md",
      "headings": [
        {
          "title": "What's in each row",
          "anchor": "whats-in-each-row"
        },
        {
          "title": "Live tail",
          "anchor": "live-tail"
        },
        {
          "title": "Filtering",
          "anchor": "filtering"
        },
        {
          "title": "From the SDK",
          "anchor": "from-the-sdk"
        },
        {
          "title": "Common queries",
          "anchor": "common-queries"
        },
        {
          "title": "\"Why did this fail?\"",
          "anchor": "why-did-this-fail"
        },
        {
          "title": "\"Which secret did this request use?\"",
          "anchor": "which-secret-did-this-request-use"
        },
        {
          "title": "\"What did our AI agent do last quarter?\"",
          "anchor": "what-did-our-ai-agent-do-last-quarter"
        },
        {
          "title": "\"Show me all calls by Dr. Smith\"",
          "anchor": "show-me-all-calls-by-dr-smith"
        },
        {
          "title": "Export",
          "anchor": "export"
        },
        {
          "title": "Retention",
          "anchor": "retention"
        },
        {
          "title": "Programmatic alerting (Phase 5)",
          "anchor": "programmatic-alerting-phase-5"
        },
        {
          "title": "Real-world example  -  compliance dashboard for a multi-tenant healthcare app",
          "anchor": "real-world-example-compliance-dashboard-for-a-multi-tenant-healthcare-app"
        },
        {
          "title": "Troubleshooting",
          "anchor": "troubleshooting"
        },
        {
          "title": "Frequently asked",
          "anchor": "frequently-asked"
        }
      ],
      "content_excerpt": "# Audit Log\n\nEvery outbound call from your sandbox is recorded automatically. No setup. The Audit Log tab on each sandbox/computer is the source of truth for \"what did my workload actually do on the network?\"\n\n## What's in each row\n\n| Column | Description |\n|---|---|\n| `timestamp` | When the request happened (microsecond precision) |\n| `host` | Upstream hostname |\n| `method` | GET, POST, PUT, … |\n| `path` | URL path (query string redacted) |\n| `action` | `allow`, `reject`, `stub`, `error`, `clie"
    },
    {
      "slug": "security/connect-accounts",
      "path": "/docs/security/connect-accounts",
      "url": "https://miosa.ai/docs/security/connect-accounts",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/security/connect-accounts",
      "title": "Connect Accounts (OAuth)",
      "description": "Authorize accounts (GitHub, Google, Slack, …) once. MIOSA manages token refresh; your sandbox sees an env var.",
      "source": "src/routes/docs/security/connect-accounts/+page.md",
      "headings": [
        {
          "title": "When to use this over Secrets",
          "anchor": "when-to-use-this-over-secrets"
        },
        {
          "title": "Connect a GitHub account (the typical flow)",
          "anchor": "connect-a-github-account-the-typical-flow"
        },
        {
          "title": "From the dashboard",
          "anchor": "from-the-dashboard"
        },
        {
          "title": "From the SDK",
          "anchor": "from-the-sdk"
        },
        {
          "title": "Supported providers",
          "anchor": "supported-providers"
        },
        {
          "title": "Machine OAuth (client credentials)",
          "anchor": "machine-oauth-client-credentials"
        },
        {
          "title": "What the proxy injects",
          "anchor": "what-the-proxy-injects"
        },
        {
          "title": "Rotation, revocation, scope changes",
          "anchor": "rotation-revocation-scope-changes"
        },
        {
          "title": "White-label OAuth (your branding, not MIOSA's)",
          "anchor": "white-label-oauth-your-branding-not-miosas"
        },
        {
          "title": "Real-world example  -  agent reads GitHub issues and posts Slack updates",
          "anchor": "real-world-example-agent-reads-github-issues-and-posts-slack-updates"
        },
        {
          "title": "Troubleshooting",
          "anchor": "troubleshooting"
        },
        {
          "title": "Frequently asked",
          "anchor": "frequently-asked"
        }
      ],
      "content_excerpt": "# Connect Accounts (OAuth)\n\nInstead of pasting a personal-access token or API key, **authorize an account** directly with the upstream provider. MIOSA stores the access + refresh tokens, refreshes them in the background, and exposes the current valid access token to your sandbox as a plain environment variable.\n\n## When to use this over Secrets\n\n| You have… | Use |\n|---|---|\n| An API key string (e.g., OpenAI `sk-…`, Stripe `sk_live_…`) | [Secrets](/docs/security/secrets) |\n| An account where the"
    },
    {
      "slug": "security/network",
      "path": "/docs/security/network",
      "url": "https://miosa.ai/docs/security/network",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/security/network",
      "title": "Network Allowlist",
      "description": "Watch what your sandbox calls. When you're ready, lock it down with a one-click allowlist. Reversible.",
      "source": "src/routes/docs/security/network/+page.md",
      "headings": [
        {
          "title": "The two modes",
          "anchor": "the-two-modes"
        },
        {
          "title": "The \"watch then enforce\" flow",
          "anchor": "the-watch-then-enforce-flow"
        },
        {
          "title": "Day 0  -  Sandbox is created",
          "anchor": "day-0-sandbox-is-created"
        },
        {
          "title": "Day 0-7  -  Use your sandbox normally",
          "anchor": "day-0-7-use-your-sandbox-normally"
        },
        {
          "title": "Day 7+  -  Visit the Network tab",
          "anchor": "day-7-visit-the-network-tab"
        },
        {
          "title": "After lockdown  -  New hosts go to Pending",
          "anchor": "after-lockdown-new-hosts-go-to-pending"
        },
        {
          "title": "SDK  -  Network controls",
          "anchor": "sdk-network-controls"
        },
        {
          "title": "Pattern matching",
          "anchor": "pattern-matching"
        },
        {
          "title": "Per-resource vs tenant-wide rules",
          "anchor": "per-resource-vs-tenant-wide-rules"
        },
        {
          "title": "When to use warn-mode rules",
          "anchor": "when-to-use-warn-mode-rules"
        },
        {
          "title": "Rolling back",
          "anchor": "rolling-back"
        },
        {
          "title": "Real-world example  -  Python data pipeline locked to its upstream services",
          "anchor": "real-world-example-python-data-pipeline-locked-to-its-upstream-services"
        },
        {
          "title": "Troubleshooting",
          "anchor": "troubleshooting"
        },
        {
          "title": "Frequently asked",
          "anchor": "frequently-asked"
        }
      ],
      "content_excerpt": "# Network Allowlist\n\nBy default, every new MIOSA sandbox runs in **audit-only mode**: every outbound call is recorded, none are blocked. After your sandbox has been running for a while, MIOSA shows you the list of hosts it actually contacted  -  and you can flip to **enforce mode** in one click, with that list as the allowlist.\n\nLockdown is never applied automatically. You explicitly click \"Lock Down\"  -  and you can revert to audit-only at any time with one click. No data is lost in either dire"
    },
    {
      "slug": "security/secrets",
      "path": "/docs/security/secrets",
      "url": "https://miosa.ai/docs/security/secrets",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/security/secrets",
      "title": "Secrets  -  Quickstart",
      "description": "Store API keys in MIOSA. Your sandbox uses an opaque placeholder. The real key never lives inside the VM.",
      "source": "src/routes/docs/security/secrets/+page.md",
      "headings": [
        {
          "title": "Add an API key (30 seconds)",
          "anchor": "add-an-api-key-30-seconds"
        },
        {
          "title": "From the dashboard",
          "anchor": "from-the-dashboard"
        },
        {
          "title": "From the SDK",
          "anchor": "from-the-sdk"
        },
        {
          "title": "How the placeholder works",
          "anchor": "how-the-placeholder-works"
        },
        {
          "title": "Rotate a key",
          "anchor": "rotate-a-key"
        },
        {
          "title": "List + delete",
          "anchor": "list-delete"
        },
        {
          "title": "Scope levels",
          "anchor": "scope-levels"
        },
        {
          "title": "Runtime profiles vs secrets",
          "anchor": "runtime-profiles-vs-secrets"
        },
        {
          "title": "What the proxy can do beyond a string swap",
          "anchor": "what-the-proxy-can-do-beyond-a-string-swap"
        },
        {
          "title": "All 5 SDKs",
          "anchor": "all-5-sdks"
        },
        {
          "title": "Real-world example  -  multi-service agent with OpenAI and Stripe",
          "anchor": "real-world-example-multi-service-agent-with-openai-and-stripe"
        },
        {
          "title": "Troubleshooting",
          "anchor": "troubleshooting"
        },
        {
          "title": "Frequently asked",
          "anchor": "frequently-asked"
        }
      ],
      "content_excerpt": "# Secrets  -  Quickstart\n\nStore an API key once in MIOSA. Every sandbox using it sees an opaque placeholder env var. Rotate in one place, every sandbox picks up the new value automatically.\n\n## Add an API key (30 seconds)\n\n### From the dashboard\n\n```\n1. Open your Sandbox or Computer in the MIOSA dashboard\n2. Click the \"Secrets\" tab\n3. Click \"+ Add Secret\"\n4. Fill in:\n     Name:        openai_key\n     Value:       sk-proj-...  (paste your real key)\n     Expose as:   OPENAI_API_KEY\n5. Save\n```\n\nIn"
    },
    {
      "slug": "security/troubleshooting",
      "path": "/docs/security/troubleshooting",
      "url": "https://miosa.ai/docs/security/troubleshooting",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/security/troubleshooting",
      "title": "Security  -  Troubleshooting",
      "description": "Top 15 issues across MIOSA Secrets, Connect Accounts, Network Allowlist, Audit Log, and White-label Credentials  -  with root causes and fixes.",
      "source": "src/routes/docs/security/troubleshooting/+page.md",
      "headings": [
        {
          "title": "Secrets",
          "anchor": "secrets"
        },
        {
          "title": "1. Secret value is not being swapped  -  outbound request uses the raw placeholder",
          "anchor": "1-secret-value-is-not-being-swapped-outbound-request-uses-the-raw-placeholder"
        },
        {
          "title": "2. secrets.list() shows the secret but $ENVVAR is empty inside the sandbox",
          "anchor": "2-secretslist-shows-the-secret-but-envvar-is-empty-inside-the-sandbox"
        },
        {
          "title": "3. Rotating a key doesn't take effect  -  sandbox still uses the old key",
          "anchor": "3-rotating-a-key-doesnt-take-effect-sandbox-still-uses-the-old-key"
        },
        {
          "title": "Connect Accounts (OAuth)",
          "anchor": "connect-accounts-oauth"
        },
        {
          "title": "4. GitHub OAuth refresh failing  -  sandbox gets 401 on api.github.com",
          "anchor": "4-github-oauth-refresh-failing-sandbox-gets-401-on-apigithubcom"
        },
        {
          "title": "5. Custom OAuth provider returns \"invalidstate\"",
          "anchor": "5-custom-oauth-provider-returns-invalidstate"
        },
        {
          "title": "6. Provider OAuth app shows \"Authorize MIOSA\" instead of my brand",
          "anchor": "6-provider-oauth-app-shows-authorize-miosa-instead-of-my-brand"
        },
        {
          "title": "Network Allowlist",
          "anchor": "network-allowlist"
        },
        {
          "title": "7. Sandbox can't reach pypi.org after lockdown",
          "anchor": "7-sandbox-cant-reach-pypiorg-after-lockdown"
        },
        {
          "title": "8. npm install fails after lockdown",
          "anchor": "8-npm-install-fails-after-lockdown"
        },
        {
          "title": "9. Agent stopped calling a host that's on the allowlist",
          "anchor": "9-agent-stopped-calling-a-host-thats-on-the-allowlist"
        },
        {
          "title": "10. I locked down a sandbox but all new sandboxes from the same template are locked too",
          "anchor": "10-i-locked-down-a-sandbox-but-all-new-sandboxes-from-the-same-template-are-locked-too"
        },
        {
          "title": "Audit Log",
          "anchor": "audit-log"
        },
        {
          "title": "11. Audit log is empty  -  no rows for a sandbox that's been running",
          "anchor": "11-audit-log-is-empty-no-rows-for-a-sandbox-thats-been-running"
        },
        {
          "title": "12. Audit rows show requesttransforms.secrets.swapped = [] even though a secret is bound",
          "anchor": "12-audit-rows-show-requesttransformssecretsswapped-even-though-a-secret-is-bound"
        },
        {
          "title": "White-label",
          "anchor": "white-label"
        },
        {
          "title": "13. Audit query by externaluserid returns rows from other users",
          "anchor": "13-audit-query-by-externaluserid-returns-rows-from-other-users"
        },
        {
          "title": "14. scope=\"externaluser\" secret returns 403",
          "anchor": "14-scopeexternaluser-secret-returns-403"
        },
        {
          "title": "15. Resolver scope walk skips an expected secret",
          "anchor": "15-resolver-scope-walk-skips-an-expected-secret"
        },
        {
          "title": "Still stuck?",
          "anchor": "still-stuck"
        }
      ],
      "content_excerpt": "# Security  -  Troubleshooting\n\nQuick-reference for the 15 most common issues across all MIOSA Security features. Each entry: symptom → root cause → fix.\n\n---\n\n## Secrets\n\n### 1. Secret value is not being swapped  -  outbound request uses the raw placeholder\n\n**Symptom**: Your sandbox sees `miosa-tok-...` in `$OPENAI_API_KEY` and that placeholder reaches the upstream API, which returns a 401.\n\n**Root cause**: The proxy swaps placeholders by scanning the outbound request for known token prefixes."
    },
    {
      "slug": "security/white-label",
      "path": "/docs/security/white-label",
      "url": "https://miosa.ai/docs/security/white-label",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/security/white-label",
      "title": "End-user credentials and OAuth",
      "description": "How to scope secrets and OAuth connections to your own end-users on top of MIOSA  -  with your branding, not ours.",
      "source": "src/routes/docs/security/white-label/+page.md",
      "headings": [
        {
          "title": "Background  -  external attribution",
          "anchor": "background-external-attribution"
        },
        {
          "title": "Stamping attribution at create time",
          "anchor": "stamping-attribution-at-create-time"
        },
        {
          "title": "Storing a credential scoped to an end-user",
          "anchor": "storing-a-credential-scoped-to-an-end-user"
        },
        {
          "title": "How the proxy decides which credential to use",
          "anchor": "how-the-proxy-decides-which-credential-to-use"
        },
        {
          "title": "White-label OAuth (your branding, not MIOSA's)",
          "anchor": "white-label-oauth-your-branding-not-miosas"
        },
        {
          "title": "1. Register your own OAuth app on the provider",
          "anchor": "1-register-your-own-oauth-app-on-the-provider"
        },
        {
          "title": "2. Drop the credentials into MIOSA",
          "anchor": "2-drop-the-credentials-into-miosa"
        },
        {
          "title": "3. Make sure your callback proxies to MIOSA",
          "anchor": "3-make-sure-your-callback-proxies-to-miosa"
        },
        {
          "title": "Per-user auditing",
          "anchor": "per-user-auditing"
        },
        {
          "title": "Privacy boundary",
          "anchor": "privacy-boundary"
        },
        {
          "title": "Disabling end-user-scoped credentials entirely",
          "anchor": "disabling-end-user-scoped-credentials-entirely"
        },
        {
          "title": "Real-world example  -  ClinicIQ: AI medical assistant per clinician",
          "anchor": "real-world-example-cliniciq-ai-medical-assistant-per-clinician"
        },
        {
          "title": "Troubleshooting",
          "anchor": "troubleshooting"
        },
        {
          "title": "Frequently asked",
          "anchor": "frequently-asked"
        }
      ],
      "content_excerpt": "# End-user credentials and OAuth\n\nIf you're building a product **on top of MIOSA** (an AI coding agent, a vertical SaaS, an agency tool) and your end-users create sandboxes through *your* UI, MIOSA Security supports them as first-class identities  -  even though they don't have MIOSA accounts.\n\nThis page covers:\n\n1. Attributing sandboxes to your end-users with `external_user_id`\n2. Storing credentials scoped to those end-users\n3. Branding the OAuth consent flow as your own product\n4. Auditing pe"
    },
    {
      "slug": "ui-components",
      "path": "/docs/ui-components",
      "url": "https://miosa.ai/docs/ui-components",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/ui-components",
      "title": "UI Components",
      "description": "Drop-in React, Vue, and Svelte components for embedding MIOSA sandboxes in your own frontend.",
      "source": "src/routes/docs/ui-components/+page.md",
      "headings": [
        {
          "title": "Auth model",
          "anchor": "auth-model"
        },
        {
          "title": "Which framework package to choose",
          "anchor": "which-framework-package-to-choose"
        },
        {
          "title": "Install",
          "anchor": "install"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "`@miosa/react`, `@miosa/vue`, and `@miosa/svelte` are drop-in component libraries that let you embed live MIOSA sandboxes directly in your own frontend  -  no iframe glue code, no WebSocket wiring, no API plumbing.\n\nEach package ships four production-ready components:\n\n| Component | What it renders |\n|---|---|\n| `` | A sandboxed iframe showing your sandbox's HTTP preview URL |\n| `` | A full xterm.js terminal connected to a sandbox PTY over WebSocket |\n| `` | An interactive file browser backed by"
    },
    {
      "slug": "ui-components/foundation",
      "path": "/docs/ui-components/foundation",
      "url": "https://miosa.ai/docs/ui-components/foundation",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/ui-components/foundation",
      "title": "Foundation UI",
      "description": "The owned MIOSA frontend primitives used by the platform application.",
      "source": "src/routes/docs/ui-components/foundation/+page.md",
      "headings": [
        {
          "title": "Owned primitive surface",
          "anchor": "owned-primitive-surface"
        },
        {
          "title": "Import path",
          "anchor": "import-path"
        },
        {
          "title": "Compute workspace audit",
          "anchor": "compute-workspace-audit"
        },
        {
          "title": "Cleanup order",
          "anchor": "cleanup-order"
        },
        {
          "title": "Verification guardrail",
          "anchor": "verification-guardrail"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "The MIOSA platform owns a Foundation UI primitive set exposed to the Svelte app through the `$foundation` alias.\n\nUse this surface for platform screens before adding route-local buttons, inputs, cards, modals, tabs, tables, or page chrome.\n\n## Owned primitive surface\n\n| Primitive group | Components |\n|---|---|\n| Actions | `Button`, `PillButton` |\n| Forms | `Input`, `RoundedInput`, `Textarea`, `Select`, `Checkbox`, `Toggle`, `RadioGroup`, `Slider` |\n| Layout | `GlassCard`, `AppCard`, `Separator`,"
    },
    {
      "slug": "ui-components/react",
      "path": "/docs/ui-components/react",
      "url": "https://miosa.ai/docs/ui-components/react",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/ui-components/react",
      "title": "React UI Components",
      "description": "Drop-in React components for embedding MIOSA sandboxes  -  MiosaPreview, MiosaTerminal, MiosaFileTree, MiosaUsage.",
      "source": "src/routes/docs/ui-components/react/+page.md",
      "headings": [
        {
          "title": "Install",
          "anchor": "install"
        },
        {
          "title": "MiosaThemeProvider",
          "anchor": "miosathemeprovider"
        },
        {
          "title": "Props",
          "anchor": "props"
        },
        {
          "title": "MiosaPreview",
          "anchor": "miosapreview"
        },
        {
          "title": "Props",
          "anchor": "props"
        },
        {
          "title": "States",
          "anchor": "states"
        },
        {
          "title": "MiosaTerminal",
          "anchor": "miosaterminal"
        },
        {
          "title": "Props",
          "anchor": "props"
        },
        {
          "title": "Peer dependencies",
          "anchor": "peer-dependencies"
        },
        {
          "title": "MiosaFileTree",
          "anchor": "miosafiletree"
        },
        {
          "title": "Props",
          "anchor": "props"
        },
        {
          "title": "FileNode type",
          "anchor": "filenode-type"
        },
        {
          "title": "MiosaUsage",
          "anchor": "miosausage"
        },
        {
          "title": "Props",
          "anchor": "props"
        },
        {
          "title": "Theming and styling",
          "anchor": "theming-and-styling"
        },
        {
          "title": "End-to-end example: Next.js",
          "anchor": "end-to-end-example-nextjs"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "`@miosa/react` v0.3.2 provides four React components for embedding MIOSA sandboxes in any React application.\n\n## Install\n\n```bash\nnpm install @miosa/react\n# xterm peer deps  -  required only if you use MiosaTerminal\nnpm install @xterm/xterm @xterm/addon-fit\n```\n\nAdd the bundled stylesheet to your app entry point:\n\n```ts\n\n```\n\n## MiosaThemeProvider\n\nWrap your component tree with `MiosaThemeProvider` to set a default theme for all nested Miosa components.\n\n```tsx\n\nexport default function App() {\n "
    },
    {
      "slug": "ui-components/svelte",
      "path": "/docs/ui-components/svelte",
      "url": "https://miosa.ai/docs/ui-components/svelte",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/ui-components/svelte",
      "title": "Svelte UI Components",
      "description": "Drop-in Svelte 5 components for embedding MIOSA sandboxes  -  MiosaPreview, MiosaTerminal, MiosaFileTree, MiosaUsage.",
      "source": "src/routes/docs/ui-components/svelte/+page.md",
      "headings": [
        {
          "title": "Install",
          "anchor": "install"
        },
        {
          "title": "MiosaPreview",
          "anchor": "miosapreview"
        },
        {
          "title": "Props",
          "anchor": "props"
        },
        {
          "title": "Events",
          "anchor": "events"
        },
        {
          "title": "MiosaTerminal",
          "anchor": "miosaterminal"
        },
        {
          "title": "Props",
          "anchor": "props"
        },
        {
          "title": "Events",
          "anchor": "events"
        },
        {
          "title": "MiosaFileTree",
          "anchor": "miosafiletree"
        },
        {
          "title": "Props",
          "anchor": "props"
        },
        {
          "title": "Events",
          "anchor": "events"
        },
        {
          "title": "MiosaUsage",
          "anchor": "miosausage"
        },
        {
          "title": "Props",
          "anchor": "props"
        },
        {
          "title": "createMiosaClient store",
          "anchor": "createmiosaclient-store"
        },
        {
          "title": "End-to-end example: SvelteKit",
          "anchor": "end-to-end-example-sveltekit"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "`@miosa/svelte` v0.3.2 provides four Svelte 5 components for embedding MIOSA sandboxes. All components use Svelte 5 runes (`$props`, `$state`, `$derived`, `$effect`) and work with SvelteKit out of the box.\n\n## Install\n\n```bash\nnpm install @miosa/svelte\n# xterm peer deps  -  required only if you use MiosaTerminal\nnpm install @xterm/xterm xterm-addon-fit\n```\n\nStyles are scoped inside each `.svelte` file  -  no global stylesheet import required.\n\n## MiosaPreview\n\nRenders a sandboxed `<iframe>` show"
    },
    {
      "slug": "ui-components/vue",
      "path": "/docs/ui-components/vue",
      "url": "https://miosa.ai/docs/ui-components/vue",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/ui-components/vue",
      "title": "Vue UI Components",
      "description": "Drop-in Vue 3 components for embedding MIOSA sandboxes  -  MiosaPreview, MiosaTerminal, MiosaFileTree, MiosaUsage.",
      "source": "src/routes/docs/ui-components/vue/+page.md",
      "headings": [
        {
          "title": "Install",
          "anchor": "install"
        },
        {
          "title": "MiosaPreview",
          "anchor": "miosapreview"
        },
        {
          "title": "Props",
          "anchor": "props"
        },
        {
          "title": "Events",
          "anchor": "events"
        },
        {
          "title": "MiosaTerminal",
          "anchor": "miosaterminal"
        },
        {
          "title": "Props",
          "anchor": "props"
        },
        {
          "title": "Events",
          "anchor": "events"
        },
        {
          "title": "MiosaFileTree",
          "anchor": "miosafiletree"
        },
        {
          "title": "Props",
          "anchor": "props"
        },
        {
          "title": "Events",
          "anchor": "events"
        },
        {
          "title": "MiosaUsage",
          "anchor": "miosausage"
        },
        {
          "title": "Props",
          "anchor": "props"
        },
        {
          "title": "End-to-end example: Nuxt 3",
          "anchor": "end-to-end-example-nuxt-3"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "`@miosa/vue` v0.3.2 provides four Vue 3 single-file components for embedding MIOSA sandboxes. All components are written with `\n\n<template>\n  <!-- Recommended: short-lived preview token from your backend -->\n   console.error(err)\"\n  />\n</template>\n```\n\n### Props\n\n| Prop | Type | Default | Description |\n|---|---|---|---|\n| `sandboxId` | `string` |  -  | **Required.** The sandbox ID to preview. |\n| `previewToken` | `string` |  -  | Short-lived preview token from your backend. Mutually exclusive wi"
    },
    {
      "slug": "use-cases",
      "path": "/docs/use-cases",
      "url": "https://miosa.ai/docs/use-cases",
      "fallbackUrl": "https://miosa.roberto-c49.workers.dev/docs/use-cases",
      "title": "What you can build with MIOSA",
      "description": "Concrete product patterns for MIOSA sandboxes, computers, agent runtimes, generated artifacts, previews, and deployments.",
      "source": "src/routes/docs/use-cases/+page.md",
      "headings": [
        {
          "title": "Common product categories",
          "anchor": "common-product-categories"
        },
        {
          "title": "Product primitives",
          "anchor": "product-primitives"
        },
        {
          "title": "Build an agent-company product",
          "anchor": "build-an-agent-company-product"
        },
        {
          "title": "Example: generated app builder",
          "anchor": "example-generated-app-builder"
        },
        {
          "title": "Example: artifact workspace",
          "anchor": "example-artifact-workspace"
        },
        {
          "title": "Example: browser plus code workflow",
          "anchor": "example-browser-plus-code-workflow"
        },
        {
          "title": "Sandbox templates should map to product jobs",
          "anchor": "sandbox-templates-should-map-to-product-jobs"
        },
        {
          "title": "What to show users in your product",
          "anchor": "what-to-show-users-in-your-product"
        },
        {
          "title": "See also",
          "anchor": "see-also"
        }
      ],
      "content_excerpt": "# What you can build with MIOSA\n\nMIOSA is a runtime platform for AI products. It gives your application persistent\ncloud workspaces where agents can write files, run commands, preview web apps,\ncreate artifacts, use browser desktops, and publish durable deployments.\n\nThe core product idea is simple:\n\n```text\nUser request\n  -> agent plans work\n  -> sandbox does code, files, builds, tests, artifacts\n  -> computer does browser, desktop, screenshots, manual-style tasks\n  -> MIOSA streams events and "
    }
  ]
}