@patdown/packs 0.6.0

package/LICENSE

@@ -0,0 +1,13 @@
+Zero-Clause BSD
+=============
+
+Permission to use, copy, modify, and/or distribute this software for
+any purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE
+FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY
+DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,28 @@
+# @patdown/packs
+
+Optional fuzzy rule packs for [patdown](https://github.com/tyler-dot-earth/patdown). Content only: the CLI still just runs rules.
+
+Install:
+
+```sh
+pnpm add -D @patdown/packs
+```
+
+Then point `--rules` at a pack directory or one rule file:
+
+```sh
+npx patdown --rules ./node_modules/@patdown/packs/typescript
+npx patdown --rules ./node_modules/@patdown/packs/typescript/do-not-launder-types-with-casts.md
+npx patdown --rules ./node_modules/@patdown/packs/effect --files-from changed.txt --verbose
+```
+
+Subpath imports resolve the same files:
+
+```ts
+import typescriptPack from '@patdown/packs/typescript'
+import launder from '@patdown/packs/typescript/do-not-launder-types-with-casts.md'
+```
+
+`@patdown/rules` is the parser library. These are markdown files, not that package.
+
+Source of truth in the repo is [`packs/`](../../packs/README.md). This package copies that tree at pack time.

package/anti-slop/README.md

@@ -0,0 +1,31 @@
+# anti-slop pack
+
+Fuzzy markdown counterpart to **[Dillon Mulroy](https://github.com/dmmulroy)'s [anti-slop](https://github.com/dmmulroy/anti-slop)** generic Oxlint rules. Credit to Mulroy for the ruleset and the “reject low-evidence TypeScript” framing; this pack rephrases those generic rules for a judge instead of an AST linter.
+
+Use it when you want a **judge-backed** check for the same type-laundering patterns static anti-slop rejects. Keep Oxlint anti-slop for exact AST hits; use this pack for paraphrases, multi-step laundering, and “looks fine to the linter” refactors.
+
+Effect-specific anti-slop stays in [`../effect`](../effect/) (or Oxlint's `anti-slop-effect` group), not here. Spacing autofix (`require-readable-spacing`) stays a formatter concern and is omitted.
+
+## Rules
+
+| Rule | Static cousin |
+|---|---|
+| [Do not chain type assertions](do-not-chain-type-assertions.md) | `no-chained-type-assertions` |
+| [Do not widen then assert](do-not-widen-then-assert.md) | `no-widen-then-assert` |
+| [Do not discard known type evidence](do-not-discard-known-type-evidence.md) | `no-known-value-widening` |
+| [Require a SAFETY comment for type assertions](require-a-safety-comment-for-type-assertions.md) | `require-safety-comment-for-type-assertion` |
+| [Do not pass unknown through function contracts](do-not-pass-unknown-through-function-contracts.md) | `no-unknown-parameters`, `no-unknown-returns`, `no-unknown-type-aliases` |
+| [Prefer named owner types over escape-hatch dictionaries](prefer-named-owner-types-over-escape-hatch-dictionaries.md) | `no-unsafe-dictionary-type`, `no-object-parameters` |
+| [Do not hide omission behind empty-object spreads](do-not-hide-omission-behind-empty-object-spreads.md) | `no-conditional-empty-object-spread` |
+| [Prefer one pass over filter-then-map](prefer-one-pass-over-filter-then-map.md) | `no-array-filter-map` |
+| [Do not copy growing reducer accumulators](do-not-copy-growing-reducer-accumulators.md) | `no-reduce-accumulator-copy` |
+| [Decode at the boundary instead of runtime typeof](decode-at-the-boundary-instead-of-runtime-typeof.md) | `no-runtime-typeof` |
+| [Prefer typed access over Reflect get and apply](prefer-typed-access-over-reflect-get-and-apply.md) | `no-reflect-get`, `no-reflect-apply` |
+| [Replace dependencies through real seams](replace-dependencies-through-real-seams.md) | `no-module-mocking` |
+| [Do not put shape in symbol names](do-not-put-shape-in-symbol-names.md) | `no-shape-in-symbol-names` |
+
+## Use
+
+```sh
+npx patdown --rules ./node_modules/@patdown/packs/anti-slop --files-from changed.txt --verbose
+```

package/anti-slop/decode-at-the-boundary-instead-of-runtime-typeof.md

@@ -0,0 +1,19 @@
+# Decode at the boundary instead of runtime typeof
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Do not use ad hoc `typeof` narrowing to invent domain meaning for external values. Decode into a meaningful type at the I/O boundary (Schema, zod, etc.), then trust that type downstream.
+
+## Not allowed
+
+```
+function port(raw: unknown) {
+  if (typeof raw === 'number') return raw
+  if (typeof raw === 'string') return Number(raw)
+  throw new Error('bad port')
+}
+```
+
+## Exceptions
+
+Existence probes against the string `'undefined'` (feature detection) are fine. User-defined type predicates that are themselves the boundary decode may inspect `typeof` when necessary.

package/anti-slop/do-not-chain-type-assertions.md

@@ -0,0 +1,16 @@
+# Do not chain type assertions
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Do not nest or chain `as` / angle-bracket assertions to invent a type the value does not have. One unjustified assertion is already weak; a chain (`as unknown as T`, `as object as T`) is almost always laundering.
+
+## Not allowed
+
+```
+const user = input as unknown as User
+const value = <Config>(<unknown>raw)
+```
+
+## Exceptions
+
+A chain made only of `as const` is fine. A single assertion next to a non-empty `SAFETY:` comment that states a real invariant is fine when the surrounding code establishes that invariant.

package/anti-slop/do-not-copy-growing-reducer-accumulators.md

@@ -0,0 +1,16 @@
+# Do not copy growing reducer accumulators
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Inside `reduce` / `reduceRight`, do not copy the accumulator on every iteration with `Object.assign({}, acc, …)`, `Array.from(acc)`, `concat`, `slice`, or similar. Mutate a fresh, locally owned accumulator and return it, or use an iterator pipeline / `flatMap`. Pair with static `oxc/no-accumulating-spread` for spread copies.
+
+## Not allowed
+
+```
+items.reduce((acc, item) => Object.assign({}, acc, { [item.id]: item }), {})
+items.reduce((acc, item) => acc.concat([item]), [])
+```
+
+## Exceptions
+
+Mutating a fresh local accumulator (`acc.push(item); return acc`) is fine. Copying individual input items (not the accumulator) is fine. Bounded one-shot copies outside a growing loop are fine when ownership is clear.

package/anti-slop/do-not-discard-known-type-evidence.md

@@ -0,0 +1,16 @@
+# Do not discard known type evidence
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Do not force a value that already has useful type evidence into an explicit broad or anonymous target (`unknown`, `object`, `{}`, open `Record<string, …>`, or a hand-written anonymous object type) when that annotation's only job is to throw away keys, brands, or precision. Prefer inference, `satisfies`, or a named owner type.
+
+## Not allowed
+
+```
+const handlers: Record<string, Handler> = { start: startHandler }
+const payload: object = { id: userId }
+```
+
+## Exceptions
+
+Empty dictionary accumulators you intentionally grow, finite-key `Record` targets that match a real wire contract, and `satisfies Record<string, Handler>` (which keeps the known keys) are fine.

package/anti-slop/do-not-hide-omission-behind-empty-object-spreads.md

@@ -0,0 +1,18 @@
+# Do not hide omission behind empty-object spreads
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Do not use conditional empty-object spreads to pretend a property was always part of the object when the honest model is “property present or absent”. Prefer building the object in branches or using optional fields explicitly. Omission is not the same as assigning `undefined`.
+
+## Not allowed
+
+```
+return {
+  id,
+  ...(name === undefined ? {} : { name }),
+}
+```
+
+## Exceptions
+
+Merging option bags from a library that documents empty-object spreads as the API is fine. Spreading a real partial object (`...options`) is fine.

package/anti-slop/do-not-pass-unknown-through-function-contracts.md

@@ -0,0 +1,18 @@
+# Do not pass unknown through function contracts
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Do not use `unknown` (or a Promise of `unknown`, or an alias that only hides `unknown`) as a standing parameter or return contract. Decode unknown input at the I/O boundary into a named type, then pass that type through the rest of the program.
+
+## Not allowed
+
+```
+function handle(body: unknown): Promise<unknown> {
+  return save(body as User)
+}
+type Payload = unknown
+```
+
+## Exceptions
+
+An explicit `cause: unknown` catch parameter is fine. The exact subject of a user-defined type predicate may be `unknown`. Dynamic import / host JSON boundaries may decode from `unknown` once, then return a named type.

package/anti-slop/do-not-put-shape-in-symbol-names.md

@@ -0,0 +1,17 @@
+# Do not put shape in symbol names
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Do not use the substring `shape` (any casing) in names you own—variables, functions, types, private fields, JSX identifiers. Prefer domain words (`fields`, `schema`, `layout`, `form`). Static member access on third-party APIs you cannot rename (for example Zod's `.shape`) is fine.
+
+## Not allowed
+
+```
+type UserShape = { id: string }
+function getShape(input: Form) {}
+const formShape = input
+```
+
+## Exceptions
+
+Reading `schema.shape` (or similar) from a library API you do not control is fine. Comments and strings are out of scope for this fuzzy rule unless they rename a symbol.

package/anti-slop/do-not-widen-then-assert.md

@@ -0,0 +1,21 @@
+# Do not widen then assert
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Do not annotate or assign a known value to a broad type (`unknown`, `any`, `object`, `{}`, or a wide record) and later assert it back to a narrower type. Keep the precise type from initialization through use, or parse once at the boundary into the narrow type.
+
+## Not allowed
+
+```
+const value: unknown = getConfig()
+const port = (value as Config).port
+```
+
+```
+const row = { id: userId } as Record<string, unknown>
+const id = row.id as UserId
+```
+
+## Exceptions
+
+A single decode step from `unknown` through Schema (or another parser) into a named type is fine. Interop that truly requires `unknown` at a library boundary is fine when you decode immediately afterward.

package/anti-slop/prefer-named-owner-types-over-escape-hatch-dictionaries.md

@@ -0,0 +1,18 @@
+# Prefer named owner types over escape-hatch dictionaries
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Do not use `Record<string, unknown>`, `Record<string, any>`, `{ [key: string]: object }`, bare `object`, or similar escape-hatch dictionaries as a standing contract for application data or function inputs. Prefer a named schema/type for the closed set of fields you actually read, and parse at the boundary.
+
+## Not allowed
+
+```
+function handle(body: Record<string, unknown>) {
+  return body['email'] as string
+}
+function take(value: object) {}
+```
+
+## Exceptions
+
+Open-ended user metadata that is only stored and returned opaque is fine when callers never dig fields out via cast. Generic constraints such as `T extends Record<string, unknown>` are fine. JSON AST types in parsers are fine.

package/anti-slop/prefer-one-pass-over-filter-then-map.md

@@ -0,0 +1,16 @@
+# Prefer one pass over filter-then-map
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Do not chain adjacent eager `.filter(…).map(…)` or `.map(…).filter(…)` passes over arrays when a single transformation (or a lazy iterator pipeline) expresses the same work. Prefer `.values().filter(…).map(…).toArray()` where supported, or one `flatMap` / local reducer that preserves callback order and filtering semantics.
+
+## Not allowed
+
+```
+const emails = users.filter((u) => u.active).map((u) => u.email)
+const found = users.map(lookup).filter((v) => v !== undefined)
+```
+
+## Exceptions
+
+Lazy iterator pipelines are fine. Separated filter and map with meaningful work between them are fine. Cases where intermediate arrays are intentional and documented are fine.

package/anti-slop/prefer-typed-access-over-reflect-get-and-apply.md

@@ -0,0 +1,16 @@
+# Prefer typed access over Reflect get and apply
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Do not use global `Reflect.get` or `Reflect.apply` to reach properties or call functions when typed property access or a normal call would do. Dynamic input should be parsed into a domain type (or modeled behind an interface), not probed with Reflect.
+
+## Not allowed
+
+```
+const value = Reflect.get(object, key)
+Reflect.apply(fn, thisArg, args)
+```
+
+## Exceptions
+
+Polyfill / proxy implementation code that must speak Reflect for correctness is fine. Test harnesses that intentionally exercise Reflect behavior are fine.

package/anti-slop/replace-dependencies-through-real-seams.md

@@ -0,0 +1,20 @@
+# Replace dependencies through real seams
+globs: `**/*.test.ts`
+globs: `**/*.test.tsx`
+globs: `**/*.spec.ts`
+globs: `**/*.spec.tsx`
+globs: `**/tests/**/*.ts`
+globs: `**/tests/**/*.tsx`
+
+Do not use Vitest/Jest `mock`, `doMock`, or `unstable_mockModule` to replace modules. Tests should swap dependencies through real interfaces (Effect Layers, constructor injection, test doubles you own).
+
+## Not allowed
+
+```
+vi.mock('./db')
+jest.unstable_mockModule('./db', () => ({ query: vi.fn() }))
+```
+
+## Exceptions
+
+Temporary characterization tests against an unseamed third-party module may mock when introducing a seam in the same change set—and should delete the mock once the seam exists.

package/anti-slop/require-a-safety-comment-for-type-assertions.md

@@ -0,0 +1,15 @@
+# Require a SAFETY comment for type assertions
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Every non-`const` type assertion needs a nearby comment that states the invariant being trusted (default marker `SAFETY:`). An assertion without that justification is a violation—especially when the cast is the only thing making the types line up.
+
+## Not allowed
+
+```
+const user = body as User
+```
+
+## Exceptions
+
+`as const` is fine. A nearby `SAFETY: …` (or project-configured marker) that names a real invariant is fine. Test fixtures may cast when the fake's incomplete object is intentional and commented.

package/effect/README.md

@@ -0,0 +1,37 @@
+# effect pack
+
+Effect **v4** production defaults for services, schemas, errors, time, HTTP, and tests.
+
+Sources (Effect **v4** only; do not copy Effect v2/v3 blog patterns):
+
+- [effect.solutions](https://www.effect.solutions/) — field manual (Basics, Services & Layers, Error Handling, …)
+- [Kit Langton's Effect skill](https://github.com/kitlangton/skills/tree/main/skills/effect) — branch references (schema, services, config, schedule, cache, stream, HTTP, tests)
+- [OpenCode Effect skill (`beta`)](https://github.com/anomalyco/opencode/blob/beta/.opencode/skills/effect/SKILL.md) — short v4 house style from an actively developed Effect-heavy agent codebase ([repo](https://github.com/anomalyco/opencode/tree/beta); their docs also treat `v2` as the default integration branch)
+- Optional Oxlint [anti-slop-effect](https://github.com/dmmulroy/anti-slop) group for `_tag` / Match / service-constructor policy
+
+**Modeling default here:** `Schema.Struct` + same-name `interface`, and `Schema.TaggedErrorClass` for errors. Prefer that over `Schema.Class` / `TaggedClass` as the everyday record style (effect.solutions demos Class in places; treat that as optional when you need instance methods, not the pack default).
+
+## Rules
+
+| Rule | Theme |
+|---|---|
+| [Prefer Effect for uncertain IO and boundaries](prefer-effect-for-uncertain-io-and-boundaries.md) | When to use Effect |
+| [Use Context.Service and Layer instead of hidden singletons](use-context-service-and-layer-instead-of-hidden-singletons.md) | DI / config |
+| [Prefer Effect.fn for named effectful work](prefer-effect-fn-for-named-effectful-work.md) | Basics / tracing |
+| [Keep service method requirements empty](keep-service-method-requirements-empty.md) | Services & Layers |
+| [Prefer Schema.Struct and branded domain values](prefer-schema-struct-and-branded-domain-values.md) | Data modeling |
+| [Prefer Schema and tagged errors at Effect boundaries](prefer-schema-and-tagged-errors-at-effect-boundaries.md) | Decode + errors |
+| [Yield tagged errors and recover with catchTag](yield-tagged-errors-and-recover-with-catchtag.md) | Error handling |
+| [Prefer Match over manual tag branching](prefer-match-over-manual-tag-branching.md) | Variants / anti-slop-effect |
+| [Prefer Schedule and TestClock over Date and sleep](prefer-schedule-and-testclock-over-date-and-sleep.md) | Time / retries |
+| [Prefer Effect HttpClient for outgoing HTTP](prefer-effect-httpclient-for-outgoing-http.md) | HTTP |
+| [Prefer effect Cache over hand-rolled maps](prefer-effect-cache-over-hand-rolled-maps.md) | Caching |
+| [Prefer Stream for multi-value effectful sources](prefer-stream-for-multi-value-effectful-sources.md) | Streams |
+| [Prefer Effect-aware tests and layers](prefer-effect-aware-tests-and-layers.md) | Testing |
+| [Address Effect diagnostics instead of dodging them](address-effect-diagnostics-instead-of-dodging-them.md) | Language service |
+
+## Use
+
+```sh
+npx patdown --rules ./node_modules/@patdown/packs/effect --files-from changed.txt --verbose
+```

package/effect/address-effect-diagnostics-instead-of-dodging-them.md

@@ -0,0 +1,16 @@
+# Address Effect diagnostics instead of dodging them
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Use Effect compiler and language-service suggestions to improve the implementation. Do not silence diagnostics or add indirection that only exists to evade a check.
+
+Clear violations include:
+
+- A zero-argument service method that only returns an Effect when an Effect-valued member would do. Effects are already lazy.
+- Synchronous schema decoding inside an Effect workflow when an effectful decoder would preserve the typed error channel.
+- Using an unknown-input schema decoder when the input already has the schema's encoded type.
+- Suppressing an Effect diagnostic without a specific explanation of why it does not apply.
+
+## Exceptions
+
+Unknown-input decoding at untyped boundaries (dynamic imports, host JSON) is fine. A diagnostic suppression with a comment that names the invariant is fine when that invariant is real.

package/effect/keep-service-method-requirements-empty.md

@@ -0,0 +1,17 @@
+# Keep service method requirements empty
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+`Context.Service` method signatures should not require services in `R`. Acquire dependencies in `Layer.effect` / layer construction and close them over inside methods so callers see `Effect<A, E>` (or `R = never`), not a leak of `HttpClient`, `FileSystem`, etc. Unique service ids (`@app/Users`) and `readonly` method fields are part of the same contract.
+
+## Not allowed
+
+```
+class Users extends Context.Service<Users, {
+  readonly find: (id: UserId) => Effect.Effect<User, E, HttpClient.HttpClient>
+}>()('@app/Users') {}
+```
+
+## Exceptions
+
+Framework request-scoped values that are intentionally leakable (documented with `@effect-leakable-service` / `@effect-expect-leaking`) are fine. Layers themselves may require services; only the **provided service methods** should not.

package/effect/prefer-effect-aware-tests-and-layers.md

@@ -0,0 +1,21 @@
+# Prefer Effect-aware tests and layers
+globs: `**/*.test.ts`
+globs: `**/*.test.tsx`
+globs: `**/tests/**/*.ts`
+globs: `**/tests/**/*.tsx`
+
+Test Effect programs with `@effect/vitest` (`it.effect`), explicit test Layers, and `TestClock` / Deferred / Queue synchronization. Do not `Effect.runSync` / `runPromise` inside ordinary `async` tests just to avoid Effect test tooling, and do not sleep to wait for fibers.
+
+## Not allowed
+
+```
+it('loads', async () => {
+  const user = await Effect.runPromise(loadUser(id))
+  await new Promise((r) => setTimeout(r, 50))
+  expect(user.id).toBe(id)
+})
+```
+
+## Exceptions
+
+Pure non-Effect unit tests stay on plain Vitest. Contract tests against a real HTTP server may use async/await at the outer edge while the app under test remains Effectful.

package/effect/prefer-effect-cache-over-hand-rolled-maps.md

@@ -0,0 +1,16 @@
+# Prefer effect Cache over hand-rolled maps
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+For keyed lookup caches with TTL and in-flight dedupe, prefer `Cache.make` / `Cache.makeWith` (or `Effect.cached` / `cachedWithTTL` for a single effect) over a module-level `Map` plus manual prune timers and promise dedupe. Use `Request` / `RequestResolver` only when a real batch endpoint exists.
+
+## Not allowed
+
+```
+const cache = new Map<string, { value: User; expires: number }>()
+const inflight = new Map<string, Promise<User>>()
+```
+
+## Exceptions
+
+Tiny process-local memo tables with clear ownership and no TTL/dedupe requirements are fine. Caches owned by an external library are out of scope.

package/effect/prefer-effect-fn-for-named-effectful-work.md

@@ -0,0 +1,24 @@
+# Prefer Effect.fn for named effectful work
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+In Effect v4 modules, define public and non-trivial service methods with `Effect.fn("Domain.operation")` (generator or effect-returning) so call sites get tracing spans. Use `Effect.fnUntraced` only for internal helpers where span metadata is intentionally unnecessary. Prefer `Effect.gen` for sequencing over nested `flatMap` chains.
+
+## Not allowed
+
+```
+const get = (id: UserId) =>
+  Effect.gen(function* () {
+    return yield* repo.find(id)
+  })
+```
+
+```
+function load() {
+  return fetchUser.pipe(Effect.flatMap(processUser))
+}
+```
+
+## Exceptions
+
+Trivial one-liners that only `yield*` another named effect may stay unnamed. Test-only helpers may be untraced. Non-Effect pure functions are out of scope.

package/effect/prefer-effect-for-uncertain-io-and-boundaries.md

@@ -0,0 +1,18 @@
+# Prefer Effect for uncertain IO and boundaries
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+In modules that already use Effect, wrap external IO and untrusted input with Effect APIs instead of bare `async`/`await`, raw `fetch`, or unchecked JSON. Prefer `Effect.tryPromise`, `HttpClient`, `Schema.decodeUnknownEffect`, and tagged errors over try/catch that returns `any` or swallows failures.
+
+## Not allowed
+
+```
+async function load() {
+  const res = await fetch(url)
+  return (await res.json()) as User
+}
+```
+
+## Exceptions
+
+Trivial pure helpers, type-only files, and one-line glue that does not perform IO are fine. Test setup that intentionally uses platform APIs outside an Effect is fine when the code under test is still Effectful.

package/effect/prefer-effect-httpclient-for-outgoing-http.md

@@ -0,0 +1,16 @@
+# Prefer Effect HttpClient for outgoing HTTP
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+In Effect applications, prefer Effect `HttpClient` (and schema body decoders) over raw `fetch` / SDK defaults when you need typed errors, retries (`HttpClient.retryTransient`), and layer-provided clients. Keep business logic free of transport details.
+
+## Not allowed
+
+```
+const res = yield* Effect.tryPromise(() => fetch(url))
+const json = (yield* Effect.tryPromise(() => res.json())) as User
+```
+
+## Exceptions
+
+Tiny scripts, non-Effect modules, and vendor SDKs wrapped once behind a service method are fine. Streaming uploads/downloads may use Stream/platform APIs instead of `res.json()`.

package/effect/prefer-match-over-manual-tag-branching.md

@@ -0,0 +1,16 @@
+# Prefer Match over manual tag branching
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+For tagged unions and Effect tagged errors, prefer `Match` / `Predicate.isTagged` / tagged-enum `$match` over manual `if (value._tag === 'X')` chains or `switch (value._tag)`. Construct tagged values with their Schema / `Data.taggedEnum` constructors instead of writing `{ _tag: 'X', ... }` literals.
+
+## Not allowed
+
+```
+if (result._tag === 'Success') return result.value
+const err = { _tag: 'NotFound', id } as NotFound
+```
+
+## Exceptions
+
+`Match.when` / pattern objects that mention `_tag` as part of Match itself are fine. Test fixtures may build tagged literals when no constructor exists yet.

package/effect/prefer-schedule-and-testclock-over-date-and-sleep.md

@@ -0,0 +1,16 @@
+# Prefer Schedule and TestClock over Date and sleep
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+In Effect programs and tests, use `Clock` / `TestClock` and `Schedule` (`retry`, `repeat`, spaced/exponential policies) instead of `Date.now`, `new Date()` for control flow, or `Effect.sleep` / real timers to wait for concurrency. Timeouts and retries belong in `.pipe(Effect.timeout, Effect.retry(schedule))`.
+
+## Not allowed
+
+```
+const started = Date.now()
+yield* Effect.sleep('1 second') // in a test waiting for a fiber
+```
+
+## Exceptions
+
+Formatting a timestamp for display/logs may use clock time you already read. One-shot demos/scripts outside the Effect runtime are out of scope.

package/effect/prefer-schema-and-tagged-errors-at-effect-boundaries.md

@@ -0,0 +1,16 @@
+# Prefer Schema and tagged errors at Effect boundaries
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Decode unknown input with Schema effectful decoders (`Schema.decodeUnknownEffect`, schema body decoders). Model expected failures as tagged errors (`Schema.TaggedErrorClass` / `Data.TaggedError`). Do not use `as` to skip schema validation. Prefer Struct+interface records (see the Struct/brands rule); do not reach for Schema.Class just to hold fields.
+
+## Not allowed
+
+```
+const body = JSON.parse(text) as CreateUser
+yield* Effect.fail(new NotFound({ id }))
+```
+
+## Exceptions
+
+Trusted internal construction may use `schema.make`. Unknown-input decoding at dynamic import or other untyped host boundaries is appropriate. Tests may construct tagged errors directly.

package/effect/prefer-schema-struct-and-branded-domain-values.md

@@ -0,0 +1,20 @@
+# Prefer Schema.Struct and branded domain values
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+For ordinary Effect v4 records, prefer `Schema.Struct(...)` plus a same-name `interface` over `Schema.Class` / `TaggedClass` as the default. Brand domain primitives (`UserId`, `Email`, …) so same-shaped strings cannot be mixed. Model closed variants as tagged structs/unions (or `Data.TaggedEnum` for internal workflow state) and match exhaustively.
+
+## Not allowed
+
+```
+export class User extends Schema.Class<User>('User')({
+  id: Schema.String,
+  email: Schema.String,
+}) {}
+
+function find(userId: string, postId: string) {}
+```
+
+## Exceptions
+
+`Schema.Class` is fine when you truly need instance methods/getters on the value. Wire DTOs that intentionally use plain strings before branding at the decode boundary are fine. Non-Effect TypeScript models outside Schema are out of scope for this rule.

package/effect/prefer-stream-for-multi-value-effectful-sources.md

@@ -0,0 +1,21 @@
+# Prefer Stream for multi-value effectful sources
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Prefer `Stream` (and Queue/PubSub-backed streams) for effectful sources that emit many values over time and need pull, backpressure, interruption, or transformation—SSE, uploads, logs, model tokens, pagination—rather than ad-hoc async iterators glued with bare Promises.
+
+## Not allowed
+
+```
+async function* pages() {
+  while (true) {
+    const batch = await fetchPage()
+    if (batch.length === 0) return
+    yield batch
+  }
+}
+```
+
+## Exceptions
+
+Single-shot Effects that return one array are fine. Node streams bridged once at an adapter boundary into `Stream` are fine.

package/effect/use-context-service-and-layer-instead-of-hidden-singletons.md

@@ -0,0 +1,16 @@
+# Use Context.Service and Layer instead of hidden singletons
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Application dependencies that call networks, disks, clocks, or process env should be `Context.Service` values provided by `Layer`, not module-level mutable singletons or direct `process.env` reads in business logic. Reading config through `Config` / `ConfigProvider` inside a layer is required when the value varies by environment.
+
+## Not allowed
+
+```
+export const db = new Pool(process.env.DATABASE_URL)
+export function getUser(id: string) { return db.query(id) }
+```
+
+## Exceptions
+
+Process entrypoints may read env while building layers. True constants (literal URLs for public docs, fixed algorithm names) may stay as module constants. Scripts and one-off tools are fine.

package/effect/yield-tagged-errors-and-recover-with-catchtag.md

@@ -0,0 +1,20 @@
+# Yield tagged errors and recover with catchTag
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Define expected failures with `Schema.TaggedErrorClass` (or `Data.TaggedError`). In `Effect.gen`, yield the error value directly (`yield* new NotFound({ id })`) instead of `yield* Effect.fail(new NotFound(...))`. Recover with `Effect.catchTag` / `catchTags` / Match on tags—not a broad catch that switches on `error._tag` by hand.
+
+## Not allowed
+
+```
+yield* Effect.fail(new NotFound({ id }))
+program.pipe(
+  Effect.catchAll((error) =>
+    error._tag === 'NotFound' ? fallback : Effect.fail(error),
+  ),
+)
+```
+
+## Exceptions
+
+Defects and truly unknown failures may use cause-level handlers. Mapping a foreign error into a tagged domain error at an adapter boundary is fine.

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@patdown/packs",
+  "version": "0.6.0",
+  "description": "Optional fuzzy rule packs and individual rule files for patdown",
+  "homepage": "https://github.com/tyler-dot-earth/patdown",
+  "bugs": {
+    "url": "https://github.com/tyler-dot-earth/patdown/issues"
+  },
+  "license": "0BSD",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tyler-dot-earth/patdown.git",
+    "directory": "packages/patdown-packs"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "anti-slop",
+    "effect",
+    "typescript"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./README.md",
+    "./anti-slop": "./anti-slop/README.md",
+    "./anti-slop/*": "./anti-slop/*",
+    "./effect": "./effect/README.md",
+    "./effect/*": "./effect/*",
+    "./typescript": "./typescript/README.md",
+    "./typescript/*": "./typescript/*"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "oxfmt": "^0.65.0"
+  },
+  "engines": {
+    "node": ">=22.22.2"
+  },
+  "patdown": {
+    "packageKind": "content-package"
+  },
+  "scripts": {
+    "build": "node ../../scripts/warn-direct-package-task.mjs build && node ./scripts/sync-patdown-packs.mjs",
+    "check": "node ../../scripts/warn-direct-package-task.mjs check && pnpm run lint && pnpm run format:check && pnpm run typecheck && pnpm run test",
+    "clean": "rm -rf anti-slop effect typescript LICENSE",
+    "format": "oxfmt --write package.json",
+    "format:check": "node ../../scripts/warn-direct-package-task.mjs format:check && oxfmt --check package.json",
+    "lint": "node ../../scripts/warn-direct-package-task.mjs lint && printf 'content package: no TypeScript to lint.\\n'",
+    "test": "node ../../scripts/warn-direct-package-task.mjs test && node --test tests/sync-patdown-packs.test.mjs",
+    "typecheck": "node ../../scripts/warn-direct-package-task.mjs typecheck && printf 'content package: no TypeScript to typecheck.\\n'"
+  }
+}

package/typescript/README.md

@@ -0,0 +1,16 @@
+# typescript pack
+
+TypeScript type-safety crimes and type laundering.
+
+## Rules
+
+- [Prefer discriminated unions over flag bags](prefer-discriminated-unions-over-flag-bags.md)
+- [Do not launder types with casts](do-not-launder-types-with-casts.md)
+- [Keep branded and precise types through boundaries](keep-branded-and-precise-types-through-boundaries.md)
+- [Prefer named object parameters for multi-arg functions](prefer-named-object-parameters-for-multi-arg-functions.md)
+
+## Use
+
+```sh
+npx patdown --rules ./node_modules/@patdown/packs/typescript
+```

package/typescript/do-not-launder-types-with-casts.md

@@ -0,0 +1,16 @@
+# Do not launder types with casts
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Do not use `as`, non-null assertions, or chained assertions to make a value look like a narrower type after discarding evidence. Validate at the boundary or keep the precise type. A cast whose only job is to silence the type checker is a violation.
+
+## Not allowed
+
+```
+const id = raw as UserId
+const value = (data as unknown as Config).port!
+```
+
+## Exceptions
+
+`as const` is fine. A cast next to a `SAFETY:` comment that names the invariant is fine when the surrounding code actually establishes that invariant. Test fixtures that build incomplete objects for a fake may cast when the fake's contract is intentional.

package/typescript/keep-branded-and-precise-types-through-boundaries.md

@@ -0,0 +1,16 @@
+# Keep branded and precise types through boundaries
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Do not strip branded or precise types by re-annotating them as `string`, `number`, `object`, `unknown`, or an anonymous structural type when the branded/precise type is still available. Prefer deriving with `Pick`, `Omit`, `Parameters`, `ReturnType`, or the schema's type.
+
+## Not allowed
+
+```
+function save(userId: string) { /* userId was UserId one call up */ }
+const row: { id: string } = brandedUser
+```
+
+## Exceptions
+
+Encoding to JSON/storage where the wire type is truly a string is fine at the encoder boundary. Public API surfaces that intentionally accept plain strings and brand inside are fine.

package/typescript/prefer-discriminated-unions-over-flag-bags.md

@@ -0,0 +1,15 @@
+# Prefer discriminated unions over flag bags
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Model related states as a tagged union so invalid combinations cannot compile. A single object with several optional fields or booleans that only make sense together is a violation when those fields represent mutually exclusive outcomes.
+
+## Not allowed
+
+```
+type LoadState = { loading: boolean; user?: User; error?: string }
+```
+
+## Exceptions
+
+Independent optional fields that can all be present at once are fine. Transport DTOs that mirror a wire format before decoding into a union are fine when the next step narrows them.

package/typescript/prefer-named-object-parameters-for-multi-arg-functions.md

@@ -0,0 +1,15 @@
+# Prefer named object parameters for multi-arg functions
+globs: `**/*.ts`
+globs: `**/*.tsx`
+
+Exported or cross-module functions with two or more parameters of similar or swappable types should take one named object instead of positional args. Swappable strings, numbers, or ids in adjacent positions are the main violation.
+
+## Not allowed
+
+```
+export function sendEmail(subject: string, body: string) {}
+```
+
+## Exceptions
+
+Hot numeric kernels, well-known callbacks (`(err, value) => …`), constructors matching a platform API, and single-parameter functions are fine. Methods that already use a destructured object parameter are fine.