[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-81513":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":10,"language":11,"languages":10,"totalLinesOfCode":10,"stars":12,"forks":13,"watchers":14,"openIssues":15,"contributorsCount":15,"subscribersCount":15,"size":15,"stars1d":15,"stars7d":16,"stars30d":17,"stars90d":15,"forks30d":15,"starsTrendScore":15,"compositeScore":18,"rankGlobal":10,"rankLanguage":10,"license":19,"archived":20,"fork":20,"defaultBranch":21,"hasWiki":20,"hasPages":20,"topics":22,"createdAt":10,"pushedAt":10,"updatedAt":23,"readmeContent":24,"aiSummary":25,"trendingCount":15,"starSnapshotCount":15,"syncStatus":26,"lastSyncTime":27,"discoverSource":28},81513,"MarrowScript","Doorman11991\u002FMarrowScript","Doorman11991","MarrowScript compiler. Welcome to deterministic typed LLM orchestration as a compile-time concern","",null,"TypeScript",31,1,27,0,3,4,42.8,"Other",false,"main",[],"2026-06-12 04:01:34","# MarrowScript\n\nMarrowScript is a declarative language that compiles `.marrow` files into complete, runnable Node.js backends. You describe your system once and get back a full production-ready project: database migrations, API routes, auth, events, SDK, Dockerfile, CI pipeline, and more.\n\nSame input always produces identical output. No surprises, no hidden magic.\n\n```marrow\nsystem Shop {\n  entity Product {\n    owns: [name: string, price: uint, stock: uint]\n    constraints: [price > 0, stock >= 0]\n    states: available -> sold_out | archived\n  }\n\n  capability purchase(buyer: User, product: Product, qty: uint) {\n    requires: [product.stock >= qty, buyer.balance >= product.price * qty]\n    effects: [product.stock -= qty, buyer.balance -= product.price * qty]\n    emits: OrderPlaced\n    sync: transactional\n  }\n\n  event OrderPlaced {\n    payload: { order_id: uuid, buyer_id: uuid, total: uint }\n    delivery: exactly_once\n    ttl: 90d\n  }\n\n  policy api_security {\n    rate_limit: 100 per 1m\n    audit: true\n  }\n}\n```\n\nRun `marrowc compile shop.marrow` and get back a complete project with an Express API, PostgreSQL migrations, JWT auth, transactional SQL, durable events, WebSocket support, OpenAPI spec, TypeScript SDK, React hooks, Zod schemas, admin panel, Dockerfile, and GitHub Actions CI.\n\n---\n\n## Install\n\n```bash\nnpm install -g marrowscript-compiler\n```\n\nOr run without installing:\n\n```bash\nnpx marrowscript-compiler compile shop.marrow\n```\n\nRequires Node.js 18 or later.\n\n---\n\n## Quick Start\n\n```bash\n# 1. Create a new project from a template\nmarrowc init my-app --domain saas_platform\n\n# 2. Compile it\nmarrowc compile my-app\u002Fmy-app.marrow\n\n# 3. Set up your environment\ncp my-app\u002Foutput\u002F.env.example my-app\u002Foutput\u002F.env\n# Open .env and set JWT_SECRET to a random string:\n# node -e \"console.log(require('crypto').randomBytes(48).toString('hex'))\"\n\n# 4. Start it\ncd my-app\u002Foutput\nnpm install\ndocker compose up -d\nnpm run migrate\nnpm run dev\n# Running at http:\u002F\u002Flocalhost:3000\n# Admin panel at http:\u002F\u002Flocalhost:3000\u002Fadmin\n```\n\nNo database setup required beyond Docker. Postgres and Redis start automatically from the generated `docker-compose.yaml`.\n\n---\n\n## Using MarrowScript with an LLM\n\nMarrowScript is a great fit for AI-assisted backend development. The language is structured and constrained enough that LLMs produce clean, valid `.marrow` files reliably.\n\n### Prompting an LLM to write a .marrow file\n\nGive the model a task description and the MarrowScript syntax. A useful prompt looks like this:\n\n```\nYou are writing a MarrowScript (.marrow) system definition.\n\nMarrowScript uses: entity (data), capability (operations), event (domain events),\npolicy (rate limits, audit), flow (sagas), channel (websockets).\n\nWrite a system for: [describe your system here]\n\nRules:\n- entity fields use: string, uint, int, float, bool, timestamp, uuid, json\n- capability requires: are preconditions, effects: are mutations, emits: fires events\n- sync: transactional means the capability runs in a DB transaction\n- states use: state1 -> state2 | terminated\n- policy sets rate_limit, audit, encryption\n```\n\nThen paste in the shop example above so the model understands the syntax. Most frontier models produce valid `.marrow` files on the first or second try.\n\n### Using reflect-llm to convert existing code\n\nIf you have an existing TypeScript project, MarrowScript can infer a `.marrow` stub from it automatically:\n\n```bash\n# Static inference from TypeScript (no LLM needed)\nmarrowc reflect .\u002Fmy-existing-project --out my_project.marrow\n\n# LLM-assisted inference (detects capabilities and state machines)\nmarrowc reflect-llm .\u002Fmy-existing-project --out my_project.marrow\n\n# With a custom endpoint (LM Studio, vLLM, etc.)\nmarrowc reflect-llm .\u002Fmy-existing-project --endpoint http:\u002F\u002Flocalhost:1234\u002Fv1 --model phi-3.5-mini\n```\n\nThe reflect command walks your TypeScript source, finds entity-shaped classes and interfaces, and writes a `.marrow` stub you can review and compile.\n\n### Using the LLM harness (cognition layer)\n\nMarrowScript can also compile backends that call LLMs as part of their business logic. Declare models, prompts, and routers in your `.marrow` file:\n\n```marrow\nmodel Classifier {\n  provider: openai_compat\n  endpoint: \"http:\u002F\u002Flocalhost:1234\u002Fv1\"\n  name: \"phi-3.5-mini\"\n  context_window: 128000\n  max_output: 512\n  temperature: 0.0\n  cost_class: small\n  latency_class: fast\n}\n\nprompt classify_ticket(body: string) {\n  model: Classifier\n  template: \"extension_point:tmpl_classify\"\n  returns: string\n  validate: schema_only\n  on_invalid: retry\n  retry: { max_attempts: 2, backoff: fixed, interval: 200ms }\n  cache: { key: hash(body), ttl: 1h }\n}\n```\n\nThe compiler generates the provider adapters, retry logic, cache tables, trace tables, and budget enforcement. You provide the prompt templates via extension points. Works with any OpenAI-compatible endpoint including LM Studio, Ollama, OpenRouter, and vLLM.\n\n---\n\n## Features\n\n### Entities\n\nEntities are your data models. They have fields, constraints, state machines, relations, and optional indexes. Every entity gets a full set of CRUD routes automatically.\n\n```marrow\nentity Order {\n  owns: [\n    buyer_id: uuid,\n    total: uint,\n    status: string,\n    notes: string\n  ]\n  constraints: [\n    total > 0,\n    status in [\"pending\", \"paid\", \"shipped\", \"delivered\", \"cancelled\"]\n  ]\n  states: pending -> paid -> shipped -> delivered | cancelled\n  relation buyer: belongs_to User\n  index: [buyer_id, status]\n}\n```\n\nField types: `string`, `uint`, `int`, `float`, `bool`, `timestamp`, `uuid`, `bytes`, `json`, `list\u003CT>`, `set\u003CT>`, `optional\u003CT>`\n\nMark sensitive fields with `@sensitive` so the audit middleware redacts them from logs:\n\n```marrow\nentity User {\n  owns: [\n    email: string @sensitive,\n    payment_token: string @sensitive,\n    username: string\n  ]\n}\n```\n\nUse `@renamed_from` to generate safe `ALTER TABLE ... RENAME COLUMN` migrations:\n\n```marrow\nemail_address: string @renamed_from(email)\n```\n\n### Capabilities\n\nCapabilities are the operations your system can perform. They declare preconditions that must be true before the operation runs, effects that describe what changes, and events that fire when it succeeds.\n\n```marrow\ncapability ship_order(seller: Seller, order: Order) {\n  requires: [\n    order.status == \"paid\",\n    order.seller_id == seller.id,\n    caller.id == seller.id\n  ]\n  effects: [\n    order.status = \"shipped\"\n  ]\n  emits: OrderShipped\n  sync: transactional\n  timeout: 10s\n  idempotent: true\n  retry: { max_attempts: 3, backoff: exponential, interval: 1s }\n}\n```\n\n`sync: transactional` wraps the operation in a database transaction. `sync: eventual` runs asynchronously. The `caller` built-in resolves to the authenticated actor's ID for ownership checks.\n\nEffects support assignment (`=`), increment (`+=`), and decrement (`-=`). When an effect targets an entity field, the compiler generates the correct SQL `UPDATE` statement automatically.\n\n### Events\n\nEvents are immutable records that fire when capabilities succeed. They get stored in a transactional outbox and delivered with the guarantees you specify.\n\n```marrow\nevent OrderShipped {\n  payload: {\n    order_id: uuid,\n    seller_id: uuid,\n    shipped_at: timestamp\n  }\n  delivery: exactly_once\n  ttl: 30d\n}\n```\n\nDelivery modes: `at_least_once`, `at_most_once`, `exactly_once`\n\nSwitch between in-memory and durable delivery via environment variable:\n\n```bash\nEVENT_MODE=in_process   # fast, no persistence (default for dev)\nEVENT_MODE=durable      # Postgres-backed transactional outbox\n```\n\n### Flows (Sagas)\n\nFlows are multi-step operations where each step can be compensated if something goes wrong. The compiler generates a saga runtime that runs steps in order and rolls back on failure.\n\n```marrow\nflow checkout {\n  step reserve_stock: reserve_items(cart.items)\n    compensate: release_items(cart.items)\n\n  step charge: process_payment(buyer, cart.total)\n    compensate: refund_payment(buyer, cart.total)\n\n  step confirm: create_order(buyer, cart)\n}\n```\n\n### Channels (WebSockets)\n\nChannels declare real-time communication surfaces. The compiler generates a WebSocket server wired to your entities and events automatically.\n\n```marrow\nchannel trade_feed {\n  transport: websocket\n  ordering: fifo\n  participants: set\u003CUser>\n  persistence: last_50\n  filter: participant.id == event.to_user\n}\n```\n\nOrdering options: `fifo`, `causal`, `total`, `unordered`\n\n### Policies\n\nPolicies attach rate limiting, audit logging, and access control to your routes. Declare one policy and it applies to all the modules that reference it.\n\n```marrow\npolicy api_security {\n  rate_limit: 100 per 1m\n  access: [user, admin]\n  audit: true\n  encryption: both\n}\n```\n\nAdd cost budgets to enforce per-tenant or per-user LLM spend limits:\n\n```marrow\npolicy llm_limits {\n  cost_budgets: [\n    { scope: per_tenant, window: 1h, cap_usd: 1.00, on_exceeded: error },\n    { scope: per_user, window: 1d, cap_tokens: 50000, on_exceeded: throttle, retry_after: 15m }\n  ]\n}\n```\n\n### Pipelines\n\nPipelines let you compose multiple capability calls into a single operation, with parallel execution and typed error handling.\n\n```marrow\ncapability process_checkout(buyer: Buyer, cart: Cart) {\n  pipeline: {\n    validate_cart(cart)\n    charge_payment(buyer, cart.total) as payment\n    create_order(buyer, cart, payment)\n    on_error: rollback\n  }\n  sync: transactional\n}\n```\n\nUse `parallel: true` to run pipeline steps concurrently when they have no dependencies on each other.\n\n### Stores\n\nStores declare how your data is physically stored. Most of the time you use the defaults, but stores let you configure replicas, partitioning, and retention.\n\n```marrow\nstore OrderStore {\n  engine: postgresql\n  schema: {\n    id: uuid,\n    buyer_id: uuid,\n    total: uint,\n    status: string,\n    created_at: timestamp\n  }\n  partition: buyer_id\n  replicas: 2\n}\n\nstore SessionStore {\n  engine: redis\n  schema: {\n    token: string,\n    user_id: uuid,\n    expires_at: timestamp\n  }\n  retention: 24h\n}\n```\n\n### State Machines\n\nDeclare state machines directly on entities using a simple arrow syntax. The compiler generates a typed state machine runtime and validates all transitions at compile time.\n\n```marrow\nentity Listing {\n  states: draft -> published -> sold | archived\n}\n```\n\nThis generates a `ListingState` type, a `LISTING_TRANSITIONS` table, and a `transitionListing(current, trigger)` function with full type safety. Invalid transitions return a typed error rather than throwing.\n\n### Relations\n\nRelations are declared on entities and generate SQL foreign key constraints, indexes, and junction tables automatically.\n\n```marrow\nentity Listing {\n  relation seller: belongs_to Seller\n  relation reviews: has_many Review\n  relation categories: many_to_many Category\n}\n```\n\nRelation types: `belongs_to`, `has_one`, `has_many`, `many_to_many`\n\n### Algorithms\n\nReference algorithms from a built-in catalog directly in capability bodies. The compiler generates the implementation and wires it in.\n\n```marrow\ncapability find_route(start: string, end: string) {\n  algorithm: shortest_path using {\n    graph: road_network,\n    source: start,\n    target: end\n  }\n  returns: json\n}\n```\n\nAvailable algorithms: `shortest_path`, `topological_sort`, `binary_search`, `bipartite_matching`, `round_robin`, `weighted_average`, `percentile`, `rank_by`, `consistent_hash`\n\n### Extension Points\n\nExtension points are escape hatches for custom logic that the compiler cannot generate. Declare one in your `.marrow` file and implement it in TypeScript. The implementation is preserved across recompiles.\n\n```marrow\nextension_point calculate_shipping_fee(order: Order) {\n  returns: uint\n  stable: true\n}\n```\n\nMark it `stable: true` and the compiler will error if the implementation is missing.\n\n### LLM Models and Prompts\n\nWhen your backend needs to call a language model, declare it in the `.marrow` file instead of wiring it by hand. The compiler generates provider adapters, retry logic, caching, tracing, and validation automatically.\n\n```marrow\nmodel SmallModel {\n  provider: openai_compat\n  endpoint: \"http:\u002F\u002Flocalhost:1234\u002Fv1\"\n  name: \"phi-3.5-mini\"\n  context_window: 128000\n  max_output: 2048\n  temperature: 0.0\n  cost_class: small\n  latency_class: fast\n}\n\nprompt summarize(text: string) {\n  model: SmallModel\n  template: \"extension_point:tmpl_summarize\"\n  returns: string\n  timeout: 30s\n  validate: schema_only\n  on_invalid: retry_with_repair_prompt\n  retry: { max_attempts: 3, backoff: exponential, interval: 1s }\n  cache: { key: hash(text), ttl: 1h }\n}\n```\n\nSupported providers: `openai_compat` (LM Studio, vLLM, OpenRouter, OpenAI), `ollama`, `llamacpp`, `koboldcpp`, `http`\n\n### Routers\n\nRouters let you route prompt calls to different models based on input characteristics. Define tiers with cost\u002Flatency tradeoffs and let the runtime pick the right model automatically.\n\n```marrow\nrouter cost_aware {\n  by: input.complexity\n  tier short  { max: 0.3 -> TinyModel }\n  tier medium {            -> SmallModel }\n  on_low_confidence: escalate\n  confidence_threshold: 0.65\n  fallback: SmallModel\n}\n```\n\n### Evaluations\n\nEvaluations are typed regression tests for prompts. Declare test cases with expected output characteristics and run them with `marrowc evaluate` to catch prompt regressions in CI.\n\n```marrow\nevaluation test_classifier {\n  prompt: classify_ticket\n  case short_bug {\n    input: { body: \"Button crashes on click\" }\n    expects: [\n      passes: schema_only,\n      must_contain_string: [\"bug\"]\n    ]\n  }\n  baseline: { min_pass_rate: 0.90 }\n  schedule: { on: [\"ci_pr\"] }\n}\n```\n\n---\n\n## What Gets Generated\n\n```\noutput\u002F\n├── src\u002F\n│   ├── index.ts            Express server, all routes wired\n│   ├── db.ts               Postgres connection pool\n│   ├── auth.ts             JWT middleware (algorithm-pinned HS256)\n│   ├── events.ts           Durable event bus (transactional outbox)\n│   ├── audit.ts            Audit log middleware\n│   ├── notify.ts           Email and webhook notifications\n│   ├── cron.ts             Scheduled job stubs (node-cron)\n│   ├── schemas.ts          Zod validation schemas\n│   ├── health.ts           \u002Fhealth\u002Flive, \u002Fhealth\u002Fready, \u002Fhealth\u002Fmetrics\n│   ├── logger.ts           Structured logging\n│   ├── metrics.ts          Prometheus-style counters\n│   ├── flows.ts            Saga runtime with compensation\n│   ├── routes\u002F             One file per entity\n│   ├── state_machines\u002F     One file per entity with states\n│   └── cognition\u002F          LLM harness (when prompts are declared)\n├── sdk\u002F\n│   ├── client.ts           Typed TypeScript fetch client\n│   └── react.ts            React hooks (useList, useCreate, etc.)\n├── admin\u002F\n│   └── index.html          Self-contained admin panel\n├── migrations\u002F             SQL schemas, indexes, triggers, FKs\n├── openapi.yaml            OpenAPI 3.0.3 spec\n├── schema.graphql          GraphQL schema\n├── {Name}.postman_collection.json\n├── Dockerfile\n├── docker-compose.yaml\n└── .github\u002Fworkflows\u002Fci.yaml\n```\n\n---\n\n## Compile Targets\n\n```bash\n# Full Express + PostgreSQL backend (default)\nmarrowc compile app.marrow\n\n# Nakama TypeScript runtime (game backends)\nmarrowc compile app.marrow --target nakama\n\n# Prisma schema only\nmarrowc compile app.marrow --target prisma\n\n# SQLite migrations + DB client (schema-only, no routes)\nmarrowc compile app.marrow --target sqlite\n```\n\nFlags for the express target:\n\n```bash\n--no-sdk        Skip sdk\u002Fclient.ts and sdk\u002Freact.ts\n--no-openapi    Skip openapi.yaml, schema.graphql, Postman collection\n--no-seed       Skip src\u002Fseed.ts\n```\n\n---\n\n## Commands\n\n| Command | What it does |\n|---------|--------------|\n| `marrowc compile \u003Cfile>` | Full compilation to runnable project |\n| `marrowc check \u003Cfile>` | Type-check without generating code |\n| `marrowc validate [dir]` | Run `tsc --noEmit` on generated output |\n| `marrowc fmt \u003Cfile>` | Format in place |\n| `marrowc watch \u003Cfile>` | Recompile on save |\n| `marrowc init \u003Cname> --domain \u003Cname>` | Scaffold from a domain template |\n| `marrowc diff \u003Cold.marrow> \u003Cnew.marrow>` | Show schema migration diff |\n| `marrowc reflect \u003Cproject_dir>` | Infer a .marrow stub from existing TypeScript |\n| `marrowc reflect-llm \u003Cproject_dir>` | LLM-assisted inference of capabilities |\n| `marrowc trace-to-test \u003Ctrace.json>` | Convert a recorded LLM trace to a regression test |\n| `marrowc tune-router \u003Cname>` | Analyze recorded traces against a router policy |\n| `marrowc verify-determinism \u003Cfile>` | Confirm two compilations produce identical output |\n\n### Domain Templates\n\nStart from a template with `marrowc init my-app --domain \u003Cname>`:\n\n| Template | Good for |\n|----------|----------|\n| `saas_platform` | SaaS products with multi-tenant auth, billing, subscriptions |\n| `marketplace` | Buyer\u002Fseller platforms with listings, orders, reviews |\n| `multiplayer_game` | Game backends with inventory, trading, leaderboards |\n| `social_network` | Follow graphs, feeds, messaging, notifications |\n| `iot_system` | Device management, telemetry ingestion, alerting |\n| `realtime_collaboration` | Shared editing, presence, live cursors |\n| `cognitive_scaffold` | LLM harness with prompt routing and budget enforcement |\n\n---\n\n## Environment Variables\n\nThe generated `.env.example` documents every variable. Core ones:\n\n```bash\n# Required in production\nJWT_SECRET=          # min 32 chars, generate with: node -e \"console.log(require('crypto').randomBytes(48).toString('hex'))\"\nDATABASE_URL=        # postgresql:\u002F\u002Fuser:pass@host:5432\u002Fdbname\n\n# Optional\nREDIS_URL=           # redis:\u002F\u002Flocalhost:6379\nPORT=3000\nNODE_ENV=development\nALLOWED_ORIGINS=     # comma-separated, e.g. https:\u002F\u002Fapp.example.com\n\n# Event delivery\nEVENT_MODE=in_process   # or: durable\n\n# Notifications\nNOTIFY_PROVIDER=log     # or: resend, sendgrid, webhook\nNOTIFY_API_KEY=\nNOTIFY_FROM_EMAIL=\n\n# LLM harness (only when prompts are declared)\nOPENAI_COMPAT_API_KEY=\nOLLAMA_HOST=\nLLM_ENDPOINT_ALLOWLIST=\nLLM_BUDGET_TOKENS_PER_TRACE=\nLLM_BUDGET_USD_PER_TRACE=\n```\n\n---\n\n## 5 Projects Built for MarrowScript\n\n### 1. SaaS Dashboard Product\n\nA standard SaaS product with users, teams, subscriptions, and billing has a lot of plumbing. Routes for every resource, role-based access, audit trails, email notifications when plans change, state machines for subscription status, webhooks to billing providers. MarrowScript generates all of it from a spec file. You write the business logic in extension points and skip the infrastructure entirely. The `saas_platform` template gets you to a running product in about 10 minutes.\n\n### 2. Multiplayer Game Backend\n\nGame backends need fast writes, real-time messaging between players, item trading, leaderboards, and session management. MarrowScript's `channel` and WebSocket generation, combined with the `nakama` compile target, means you get a game server with typed trade capabilities, inventory state machines, and real-time lobbies without writing a line of socket code. The `multiplayer_game` template includes player auth, item stores, trade flows with compensation, and WebSocket channels out of the box.\n\n### 3. AI-Powered API\n\nIf you are building a product where users submit requests and your backend calls an LLM to fulfill them, the cognition layer is exactly what you need. Declare your models, prompts, and confidence-based routers in the `.marrow` file. The compiler generates provider adapters, response validation, retry with repair prompts, prompt caching, per-tenant cost budgets, and trace storage. You focus on the prompt templates. Everything else is handled.\n\n### 4. Marketplace or Auction Platform\n\nMarketplaces have strict transactional requirements: a listing can only be purchased once, funds need to move atomically, disputes need audit trails, and sellers need notifications. MarrowScript's `sync: transactional` capabilities, durable events, and audit middleware make these requirements easy to express. The `marketplace` template ships with Seller, Listing, Order, Review, and Buyer entities, a complete checkout flow with compensation, and state machines on every entity.\n\n### 5. IoT Data Platform\n\nIoT backends have to ingest high-frequency telemetry, route alerts, enforce device-level rate limits, and maintain audit logs for compliance. MarrowScript's store declarations with partition keys, the event system with `at_least_once` delivery, and the policy rate limiting map cleanly onto these requirements. The `iot_system` template gives you device management, telemetry ingestion, alert routing, and API key auth.\n\n---\n\n## Project Structure\n\n```\nspec\u002F           Language spec (formal documents)\ncompiler\u002F       Compiler source (TypeScript) — marrowscript-compiler on npm\n  src\u002F          Lexer, parser, type checker, IR, emitters, CLI\nlsp\u002F            Language Server (LSP)\nvscode-ext\u002F     VS Code extension\nexamples\u002F       Example .marrow files\n```\n\n---\n\n## VS Code Extension\n\n```bash\n.\\install-extension.ps1\n```\n\nGives you syntax highlighting, real-time error diagnostics, completions, hover docs, go-to-definition, and document outline for `.marrow` files.\n\n---\n\n## Links\n\n- **npm**: [npmjs.com\u002Fpackage\u002Fmarrowscript-compiler](https:\u002F\u002Fwww.npmjs.com\u002Fpackage\u002Fmarrowscript-compiler)\n- **GitHub**: [github.com\u002FDoorman11991\u002FMarrowScript](https:\u002F\u002Fgithub.com\u002FDoorman11991\u002FMarrowScript)\n\n---\n\n## License\n\nCopyright (c) 2026 ExoCode. All rights reserved.\n\nMarrowScript is source-available. You may read, study, fork, and use this software for personal and internal commercial purposes under the following terms:\n\n1. You may use MarrowScript to build and operate products, services, and internal tools.\n2. You may not sell, license, sublicense, or distribute MarrowScript itself or a substantially similar compiler or language toolchain as a standalone product or service.\n3. You may not offer MarrowScript as a hosted service (SaaS, PaaS, cloud compiler service, or equivalent) without a separate written agreement with ExoCode.\n4. You must retain all copyright notices in any copy or derivative work.\n5. Contributions submitted to this repository are licensed back to ExoCode under these same terms.\n\nGenerated output (the code produced by running `marrowc compile`) is yours. ExoCode makes no claim on anything you build with MarrowScript.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND.\n","MarrowScript 是一种声明式语言，用于将 `.marrow` 文件编译成完整的、可运行的 Node.js 后端。它支持定义系统实体、操作能力、事件和策略等，并自动生成包括数据库迁移、API 路由、认证、事件处理、SDK、Dockerfile 和 CI 管道在内的全栈项目。其核心特点是确定性和类型安全性，确保相同的输入总是产生一致的结果，没有意外或隐藏的复杂性。适合需要快速搭建生产级后端服务的场景，尤其是希望利用大语言模型辅助开发的团队。通过简单的命令即可从零开始构建一个功能齐全的应用程序，极大地简化了开发流程。",2,"2026-06-11 04:05:19","CREATED_QUERY"]