> ## Documentation Index
> Fetch the complete documentation index at: https://docs.meow.style/llms.txt
> Use this file to discover all available pages before exploring further.

# meow.config.json

> The single config file for runtime behavior and the toolchain — a complete, closed schema reference.

`meow.config.json` is the one human-edited config for a meow project. It replaces
the usual scatter of `.eslintrc`, `.prettierrc`, `tsconfig.json`, and test configs.
Everything in it is **runtime/toolchain behavior** — dependencies, scripts, and
workspaces live in your [`package.json`](/configuration/package-json).

```json meow.config.json theme={null}
{ "mode": "strict-web" }
```

<Note>
  The config is a **closed schema**: unknown keys are a parse error, not a silent
  ignore. A typo'd key is caught immediately rather
  than quietly doing nothing. Keys use `camelCase`. Every key has a default, so the
  minimal config is `{}`.
</Note>

<Warning>
  Only `meow.config.json` is read today. A `meow.config.ts` is recognized but
  **not yet evaluated** (it requires the runtime) — meow returns a clear
  `meow.config.ts evaluation is not yet supported` error rather than guessing.
  Use JSON for now.
</Warning>

## Full schema

```jsonc meow.config.json theme={null}
{
  // Runtime mode. The main behavioral switch. Default: "strict-web".
  "mode": "strict-web", // "strict-web" | "node-compat" | "legacy"

  // Monorepo package globs.
  "workspace": {
    "packages": ["apps/*", "packages/*"]
  },

  // Runtime behavior.
  "runtime": {
    "typescript": "strip"  // only "strip" — meow strips types in place
  },

  // Install projection.
  "install": {
    "mode": "pnp"  // "pnp" | "vfs" | "materialized" | "vendor"
  },

  // Lint rule severities, keyed by rule id.
  "lint": {
    "rules": {
      "no-debugger": "error"  // "off" | "warn" | "error"
    }
  },

  // Formatter style.
  "format": {
    "style": "meow"  // the single built-in style
  },

  // Type-checking.
  "types": {
    "strict": true  // maps to tsconfig "strict"
  },

  // Test runner defaults.
  "test": {
    "isolate": true,            // run each suite in its own isolate
    "clock": "deterministic",   // "deterministic" | "system"
    "network": "fake"           // "fake" | "real"
  },

  // Per-package capability grants (forward-looking).
  "permissions": {
    "default": [],
    "packages": {}
  }
}
```

## Key reference

<ParamField path="mode" type="&#x22;strict-web&#x22; | &#x22;node-compat&#x22; | &#x22;legacy&#x22;" default="&#x22;strict-web&#x22;">
  The [runtime mode](/concepts/modes). `strict-web` is a deterministic, web-standard
  sandbox; `node-compat` (and the `legacy` alias) expose the full Node surface with
  host access. **This is the key behavioral switch** and is read on every run.
</ParamField>

<ParamField path="types.strict" type="boolean" default="true">
  Sets `strict` in the generated `.meow/tsconfig.json`. Run `meow sync` after
  changing it. Drives [`meow check`](/toolchain/check) and your editor's types.
</ParamField>

<ParamField path="lint.rules" type="object (rule id → severity)" default="{}">
  Per-rule severities for [`meow lint`](/toolchain/lint), keyed by rule id. Each
  value is `"off"`, `"warn"`, or `"error"`.
</ParamField>

<ParamField path="format.style" type="&#x22;meow&#x22;" default="&#x22;meow&#x22;">
  The formatter style. meow ships one opinionated style — there are no formatting
  knobs.
</ParamField>

<ParamField path="runtime.typescript" type="&#x22;strip&#x22;" default="&#x22;strip&#x22;">
  How TypeScript is handled for execution. meow strips types in place; this is the
  only meaningful value.
</ParamField>

<ParamField path="workspace.packages" type="string[]" default="[]">
  Glob roots for a monorepo, e.g. `["apps/*", "packages/*"]`.
</ParamField>

<ParamField path="install.mode" type="&#x22;pnp&#x22; | &#x22;vfs&#x22; | &#x22;materialized&#x22; | &#x22;vendor&#x22;" default="&#x22;pnp&#x22;">
  The intended install projection. <Tooltip tip="Today, the install layout is driven by the meow install flags (--materialize / --vendor); this config key is accepted and forward-looking.">See note below.</Tooltip>
</ParamField>

<ParamField path="test.isolate / test.clock / test.network" type="boolean / enum / enum">
  Test-runner defaults. Today [`meow test`](/toolchain/test) always runs each suite
  in a deterministic isolate; these keys are accepted and forward-looking.
</ParamField>

<ParamField path="permissions.default / permissions.packages" type="string array / object" default="[] / {}">
  Per-package capability grants (`default` is a string array; `packages` maps a
  package name to a string array). Accepted and reserved; **not yet enforced** — see
  the [permissions scope note](/concepts/permissions#scope).
</ParamField>

## What's active today

Some keys change behavior right now; others are part of the closed schema but
forward-looking. The config validates either way.

| Key                  | Status                                               |
| -------------------- | ---------------------------------------------------- |
| `mode`               | ✅ Active — read on every run                         |
| `types.strict`       | ✅ Active — drives the shadow tsconfig + `meow check` |
| `lint.rules`         | ✅ Active — rule severities for `meow lint`           |
| `format.style`       | ✅ Active — single supported value                    |
| `runtime.typescript` | ✅ Active — single supported value (`strip`)          |
| `workspace.packages` | 🔜 Accepted — monorepo support evolving              |
| `install.mode`       | 🔜 Accepted — install layout set by CLI flags today  |
| `test.*`             | 🔜 Accepted — runner is deterministic-isolate today  |
| `permissions.*`      | 🔜 Accepted — not yet enforced                       |

After editing the config, regenerate the editor/TypeScript shims:

```bash theme={null}
meow sync
```

<Card title="package.json reference" icon="box" href="/configuration/package-json">
  Dependencies, scripts, overrides, and workspaces.
</Card>