---
title: Add league and team markdown context documents
type: task
status: completed
description: >-
  Server-generated, self-contained markdown context docs (league index, rules, schedule/calendar,
  team) served at human-path + .md, plus a Copy as Markdown button on the team and league pages,
  built on one shared renderer. Transactions markdown output-format and the settings-UI label-map
  refactor are split to sibling tasks.
base_uri: user:task/league/add-league-team-markdown-context-docs.md
created_at: '2026-07-17T19:54:27.828Z'
entity_id: d8b3a002-53d3-43c3-8aeb-49a701ca295b
finished_at: '2026-07-17T22:29:03.440Z'
observations:
  - ████████████████████████████████████████████████
owner_identity_uri: █████████████████████████
priority: Medium
public_read: true
relations:
  - relates [[user:repository/active/league/ABOUT.md]]
  - relates [[user:task/league/add-transactions-markdown-output-format.md]]
  - blocks [[user:task/league/consume-shared-label-map-in-league-settings-components.md]]
started_at: '2026-07-17T20:17:11.265Z'
tags:
  - user:tag/league-xo-football.md
updated_at: '2026-07-17T22:29:49.990Z'
visibility_analyzed_at: '2026-11-05T23:48:12.831Z'
---

# Implementation Plan: League and Team Markdown Context Documents

## Overview

- Add a server-generated, self-contained markdown "context document" system for xo.football so a user can copy a stable URL from the team or league page and paste it into an agent session to load full context in a single fetch.
- Ship four curated docs — league index, league rules, league schedule (calendar), team — each served at the human URL plus a `.md` suffix and returning `text/markdown`, and add a "Copy as Markdown" button to the team page and league home page.
- Impact: any agent (or human) can obtain complete, current league/team context — rules, standings, rosters, cap, calendar — without navigating the SPA or making authenticated API calls. Docs are self-sufficient at their level and cross-link into a traversable graph (base-entity-inspired).
- Ordering: bounded, no upstream blockers (all data is already queryable). Two adjacent concerns are split into sibling tasks so this task stays surgical: markdown output-format on the transactions API (`add-transactions-markdown-output-format`) and the settings-UI consumption of the shared label map (`consume-shared-label-map-in-league-settings-components`, which this task's new constant unblocks). Historical (`?year=`) scoping and HTTP `Link: rel=alternate` discovery are designed-in extension points, deferred until their use cases are pinned.

## Background

- xo.football is a React/Redux SPA (`app/`) with an Express/PostgreSQL backend (`api/`, `libs-server/`, `libs-shared/`). Client paths: `/leagues/:lid` (home), `/leagues/:lid/teams/:tid` (team), `/leagues/:lid/settings` (rules UI), `/leagues/:lid/schedule` (matchup weeks only).
- No public/private visibility model exists on leagues. `expressjwt` is optional (`credentials_required` swallowed in `api/index.mjs`) and `require_auth` (`api/routes/leagues/middleware.mjs`) guards only mutations, so all league read data is already public — the copy button works for every league with no tokens.
- Serving order in `api/index.mjs`: `/api/*` routers, then `express.static` for `dist/` and `static/`, then the SPA catch-all `/*` → `index.html` (~line 188). New `.md` routes must register after the static handlers and before the catch-all, and are NOT under `/api`. Confirmed no conflict: the static mounts use fixed prefixes that do not overlap `/leagues/...`, and the new router registers only `.get` handlers matching its specific `.md` patterns.
- Existing markdown infra (`app/views/pages/markdown/markdown.js`) fetches static repo docs from the GitHub contents API; it is for versioned repo docs, not dynamic per-entity state, and is not reused here.
- An output-format convention already exists in-repo: `api/routes/data-views.mjs` and `api/routes/selection-combinations.mjs` implement `?export_format=` (`csv`/`json`/`md`/`html`) via a `switch` on the param plus a local `convert_to_markdown_table`, caching through the shared `redis_cache` (exported from `libs-server/index.mjs`). This is the house style; the sibling transactions task follows it. This task does not introduce a competing generic negotiator or a `node-cache` layer (node-cache is not a repo dependency).
- Data is largely one-call-per-resource server-side: `getLeague({lid, year})` (`libs-server/get-league.mjs`) merges `leagues` + `seasons` + `league_formats` + `league_scoring_formats` + divisions via LEFT JOINs; `team-stats` reads `league_team_seasonlogs` (records, PF/PA, finishes); the teams route assembles forecasts + unused draft picks; `transactions` and `matchups` are filterable record queries.
- Cap-space data path (load-bearing): `get_laegue_rosters_from_database({db, lid, year})` (note the upstream export typo) returns rosters + lineups but only backfills each player's RFA `bid` inside an `if (userId)` block (`libs-server/get-league-rosters-from-database.mjs:79`) — with no `userId` it never sets `bid`. `getExtensionAmount` returns `bid || value` for RFA-tagged players (`libs-shared/get-extension-amount.mjs:38`), so cap computed from the userId-less league-wide helper is wrong during the RFA/pre-extension window. `getRoster({tid, week, year})` (`libs-server/get-roster.mjs`) populates `bid` in its `week === 0` branch and is the correct per-team source for the team doc's cap figure.
- Human-readable labels are scattered: roster-slot and transaction display names live in `libs-shared/constants/roster-constants.mjs` and `transaction-constants.mjs`, but scoring/roster-limit/starting-lineup field labels exist only in the `app/views/components/league-settings-*` React components (no server-side export).
- Isomorphic helpers reusable server-side: `libs-shared/roster.mjs` (`Roster.availableCap`), `libs-shared/get-extension-amount.mjs`, `libs-shared/get-free-agent-period.mjs`, `libs-shared/is-santuary-period.mjs`, `libs-shared/get-restricted-free-agency-nomination-info.mjs`. Date helpers normalize to `America/New_York`.
- UI idioms: `navigator.clipboard.writeText` with a 2-second check-icon success state (`app/views/components/error-view/error-view.js`); MUI `IconButton` + `@mui/icons-material`; `PageLayout` (`app/views/layouts/page/page.js`) exposes an unused `head` prop; `BASE_URL` in `app/core/constants.js`.

### Assumptions

- `getLeague({lid, year})` merges roster/scoring format fields onto the league object (checked: `libs-server/get-league.mjs` LEFT JOINs `league_formats` and `league_scoring_formats`).
- League read data requires no authentication (checked: `expressjwt` optional in `api/index.mjs`; `require_auth` only on mutations).
- Cap space must be computed from a `bid`-populated roster source; `getRoster({tid, week, year})` supplies `bid` (week-0 branch) whereas the userId-less league-wide helper does not (checked: `get-roster.mjs`, `get-league-rosters-from-database.mjs:79`, `get-extension-amount.mjs:38`).
- A league can exist with no `seasons` row for the requested year; `getLeague` still returns a truthy league with null format/cap/date fields (checked: LEFT JOIN). Generators must guard this rather than emit `NaN`/blank docs.
- Free-agency / sanctuary / RFA date helpers normalize to Eastern Time and can be called server-side with a `league`/`season` object (checked: `get-free-agent-period.mjs`, `season.mjs`).
- Express `/leagues/:lid(\d+).md` parses `.md` as a literal suffix (checked: express `^4.21.2` bundles path-to-regexp `0.1.13`; the compiled pattern escapes `.` to `\.` and `\d+` accepts arbitrary-length ids — no fallback path needed).
- `js-yaml` is available for frontmatter emission (checked: `package.json` lists `js-yaml` `4.2.0`; no hand-rolled emitter fallback needed).
- The `playoffs` table lacks bracket/seed/round structure (checked: `db/schema.postgres.sql`) — the schedule doc derives playoff weeks from `seasons.wildcard_round`/`championship_round` and states the bracket is best-effort.
- The `matchups` table is empty until `process-matchups` runs for the year (offseason/week-0 is a routine state) — the schedule and team-schedule sections must render a "no matchups scheduled yet" path, not assume rows exist.

## Design

- High-level approach: one shared generation core in `libs-server/context-docs/` (frontmatter + render helpers, shared data resolvers) consumed by the four `.md` app-path routes. Each route imports its generator directly — no `doc_type` registry or dispatch layer (four known types, four hardcoded routes; a dispatch table earns its keep only when call sites don't know the type ahead of time). No caching layer in v1: generators run the existing queries on request; if a hot path emerges later, `redis_cache` is the established tool.
- URL scheme (documented as a rule so future additions stay consistent): an entity is `<path>.md` (`/leagues/1.md`, `/leagues/1/teams/5.md`); a named sub-view of an entity is `<path>/<view>.md` (`/leagues/1/rules.md`, `/leagues/1/schedule.md`). Sub-views are named for the reader — `rules.md` (not `settings.md`) accurately describes the format/scoring/cap/calendar content versus the SPA's editing surface.
- Frontmatter uses a fixed relation vocabulary of fetchable absolute URLs — `parent`, `children`, `related` — making the doc set traversable (the `base entity tree` analog) while remaining WebFetch-able by an external agent.
- Progressive disclosure and self-sufficiency: each doc carries enough for its level with no follow-up call required, while staying compact. The league index summarizes teams/standings and links to per-team docs (full rosters live there, not inlined). Recent transactions (~10) are summarized inline in the index; the full filterable log is deferred to the transactions markdown-format sibling task (until then the index does not emit a deep-log link).
- Lifecycle-state handling (first-class, not edge cases): no-season-row league → each route/generator guards on a configured current season (e.g. `scoring_format_id` present) and 404s with a clear "season not yet configured" message; offseason/week-0 with no matchups → schedule and team-schedule render an explicit "no matchups scheduled yet" section; empty roster (new team pre-draft) → team doc renders empty slot groups with cap space equal to the full league cap.

### Proposed folder and file structure

- `libs-server/context-docs/markdown.mjs` — combined frontmatter + render helpers: `build_frontmatter({ type, fields, related })`, `heading`, `markdown_table`, `cross_link_footer`, `format_date_et`, `section`.
- `libs-server/context-docs/get-team-managers.mjs` — `get_team_managers({ db, lid, year })` joining `teams` + `users_teams` + `users` → `{ tid: [username] }`.
- `libs-server/context-docs/get-players.mjs` — `get_players({ db, pids })` → `{ pid: { name, pos, nfl_team } }` via `db('player').whereIn('pid', pids)` (verb aligned with `get_team_managers`).
- `libs-server/context-docs/generate-league-context.mjs` — `generate_league_context({ db, lid, year })`.
- `libs-server/context-docs/generate-league-rules.mjs` — `generate_league_rules({ db, lid, year })`.
- `libs-server/context-docs/generate-league-schedule.mjs` — `generate_league_schedule({ db, lid, year })`.
- `libs-server/context-docs/generate-team-context.mjs` — `generate_team_context({ db, lid, tid, year })`.
- `libs-server/context-docs/index.mjs` — thin barrel that re-exports the four generators + helpers (no dispatch registry).
- `libs-shared/constants/league-settings-labels.mjs` — `scoring_field_labels`, `starting_lineup_labels`, `roster_limit_labels`; new, additive, consumed server-side by the rules generator (the UI-side consumption is the `consume-shared-label-map-in-league-settings-components` sibling task).
- `api/routes/context-docs.mjs` — four GET routes, each importing its generator directly and returning `text/markdown`.

### Key components and relationships

- `api/routes/context-docs.mjs` → per-route direct call to `generate_league_context` / `generate_league_rules` / `generate_league_schedule` / `generate_team_context` → `getLeague`, `getRoster` (per-team cap), team-stats/teams/matchups queries, `get_team_managers`, `get_players`, `Roster`/`getExtensionAmount`, the label map and roster/transaction constants → `markdown.mjs` → markdown string.
- The `.md` routes mount at `/` after the static handlers and before the SPA catch-all in `api/index.mjs`.
- UI: `copy-markdown-button` derives `${BASE_URL}/leagues/:lid[/teams/:tid][/...].md` from `useParams` (not `window.location.href`) and writes it via the clipboard util.

### New dependencies or configuration requirements

- None. `js-yaml` (4.2.0) and MUI are already present. No `node-cache` (not a repo dependency and not used). No schema change, no new tables.

### Knowledge Base Impact

- Domain entry doc: new in-repo `docs/context-documents.md` (canonical description of the doc set, URL scheme rule, frontmatter/relation vocabulary, self-sufficiency contract, and the docs-vs-API-format boundary). Code-local behavior, so it stays in-repo per persistence restraint — no new user-base `text/league/` doc.
- ABOUT.md: add one `[architecture]` observation to `repository/active/league/ABOUT.md` recording that context-doc markdown is served at human-path + `.md`, that self-sufficiency is a contract, and that the deep transaction log lives behind the separate API markdown-format task.
- Tags: task entity tagged `user:tag/league-xo-football.md`. No new tag.
- Relations: this task `relates` the league repo ABOUT.md, `relates` `add-transactions-markdown-output-format`, and unblocks (`blocks` reverse of `blocked_by`) `consume-shared-label-map-in-league-settings-components`.

## Notes

- Six assembly gaps the generators handle: (1) manager names — join in `get-team-managers.mjs`; (2) player name/NFL team — `get-players.mjs`; (3) live cap space — computed via `Roster` from a per-team `getRoster` source so RFA `bid` is populated, never read as a column; (4) scoring/roster labels — the new shared map; (5) named-format descriptions reused only when `league_format_id`/`scoring_format_id` matches a catalog slug, else synthesized from raw field values; (6) vestigial `tag2-4`/`ext1-4` and the bracket-less `playoffs` table are deliberately not presented as authoritative.
- The schedule doc is intentionally richer than the SPA schedule page (which shows matchup weeks only): it adds the league calendar (draft, extension deadline, FA period + live auction, trade window + deadline, RFA windows, playoff weeks, season finalize) with a current-phase banner, resolving derived windows via the isomorphic helpers.
- All dates rendered in Eastern Time with explicit labels, matching the helpers' normalization.
- The new clipboard util is the forward convention; `error-view.js` keeps its existing inline copy logic (not refactored here — out of scope).

## Plan

### Core Implementation

- [x] **Add shared league-settings label map (additive, server-consumed)**
  - File: `libs-shared/constants/league-settings-labels.mjs` (new).
  - Purpose: a single server-consumable field→label source for the rules generator; also unblocks the UI-consumption sibling task. Does NOT modify the six `league-settings-*` components (that is the sibling task's surgical scope).
  - Changes: export `scoring_field_labels` (passing/rushing/receiving/misc, including labels for the currently-unlabeled `prtd`/`krtd`/`trg`/`rush_first_down`/`rec_first_down`/`exclude_qb_kneels`/`fum_ret_td`), `starting_lineup_labels`, `roster_limit_labels`, mirroring the label strings currently inline in the components.
  - Verify: `yarn lint` clean; the rules generator imports it and the rules-generator spec asserts a labeled scoring row (`no-verify` beyond that — it is a pure data module).

- [x] **Markdown helpers (frontmatter + render)**
  - File: `libs-server/context-docs/markdown.mjs`
  - Purpose: shared primitives so every doc has consistent structure/anchors, in one file.
  - Changes: `build_frontmatter({ type, fields, related })` (via `js-yaml`), `heading`, `markdown_table(headers, rows)`, `cross_link_footer(links)`, `format_date_et(unix)`, `section(title, body)`.
  - Verify: unit assertions in `test/context-docs.spec.mjs` — frontmatter parses back to the input and contains `type`/`generated_at`/`canonical_url`; `markdown_table` renders N rows; `format_date_et` yields an ET-labeled string.

- [x] **Shared data resolvers**
  - File: `libs-server/context-docs/get-team-managers.mjs`, `libs-server/context-docs/get-players.mjs`
  - Purpose: close assembly gaps #1 and #2 with reusable joins.
  - Changes: `get_team_managers({ db, lid, year })` (teams+users_teams+users) and `get_players({ db, pids })` (single `whereIn` select of fname/lname/pos/nfl team).
  - Verify: spec asserts a seeded team resolves to its manager username and a seeded pid set resolves to non-empty names.

- [x] **League context generator (with no-season guard)**
  - File: `libs-server/context-docs/generate-league-context.mjs`
  - Purpose: the league index/entry doc.
  - Changes: no-season guard (throw a typed "season not configured" error the route maps to 404); identity line; one-line format summary linking to `rules.md`; standings table (rank, team, manager, W-L-T, PF, PA, division) from `team-stats`; divisions; current phase + key upcoming dates; recent ~10 transactions summary (no deep-log link in v1); links to `rules.md`, `schedule.md`, and each team `.md`; frontmatter children = team docs.
  - Verify: spec asserts frontmatter `type: league_context`, one standings row per team (row-count floor), links to rules/schedule/team docs present, and a no-season fixture surfaces the guard.

- [x] **League rules generator**
  - File: `libs-server/context-docs/generate-league-rules.mjs`
  - Purpose: format/scoring/cap/calendar reference doc.
  - Changes: roster construction (labeled starting slots, bench/PS/IR, position limits); scoring table (passing/rushing/receiving/misc via the shared label map); cap/FAAB/min-bid + salary-attribution rule; franchise-tag amounts (`fqb/frb/fwr/fte`) + RFA timing; deliberately omits vestigial `tag2-4`/`ext1-4`.
  - Verify: spec asserts the roster-construction section renders every starting-slot and limit with a label, the scoring section renders every present field with a human label (no raw field keys), the cap/FAAB/salary-attribution line renders, and franchise amounts appear.

- [x] **League schedule generator (with no-matchups path)**
  - File: `libs-server/context-docs/generate-league-schedule.mjs`
  - Purpose: league calendar + matchup grid.
  - Changes: current-phase banner (via `current_season` + `is_santuary_period`/`get_free_agent_period`); chronological calendar table (date ET · event · status) over the enumerated event set — draft, extension deadline, FA period start + live auction start/end, trade window start + trade deadline, RFA announcement/processing, playoff weeks, season finalize; matchup grid (completed with scores+winner, upcoming with projections, names resolved) OR an explicit "no matchups scheduled yet" section when the table is empty; playoffs best-effort with the bracket-less caveat.
  - Verify: spec asserts the calendar contains a row for each populated field in the enumerated event set (list stated in the test), matchups render with resolved team names when present, and a week-0/no-matchups fixture renders the "no matchups scheduled yet" section.

- [x] **Team context generator (bid-aware cap + empty-roster path)**
  - File: `libs-server/context-docs/generate-team-context.mjs`
  - Purpose: per-team entity doc.
  - Changes: identity + manager, division, record, standings finish; cap space computed by constructing `Roster` from a per-team `getRoster({tid, week, year})` source (so RFA `bid` is populated) + FAAB remaining (`teams.faab`); roster grouped by slot (starters/bench/PS/IR: name, pos, NFL team, salary, tag/extension) with `roster_slot_display_names`; unused draft picks; season schedule/results (`matchups` filtered `hid|aid = tid`, with the no-matchups path); recent team transactions; footer linking to index, rules, schedule, sibling teams.
  - Verify: spec asserts no raw numeric slot codes remain (all mapped), every roster `pid` resolves to a name; an RFA-tagged-player fixture asserts the cap figure uses `bid` (not `value`); an empty-roster fixture renders empty slot groups with cap == full league cap.

- [x] **Barrel export + libs-server wiring**
  - File: `libs-server/context-docs/index.mjs` (new); modify `libs-server/index.mjs`
  - Purpose: clean import surface without a dispatch registry.
  - Changes: `index.mjs` re-exports the four `generate_*` functions and the markdown helpers; add the corresponding named re-exports to `libs-server/index.mjs` so `api/routes/context-docs.mjs` resolves them via `#libs-server`.
  - Verify: spec asserts `import { generate_league_context, generate_team_context } from '#libs-server'` resolves to functions (exercises the actual import path, not the module in isolation).

- [x] **Context-doc routes**
  - File: `api/routes/context-docs.mjs` (new); modify `api/index.mjs`
  - Purpose: serve the four docs at human-path + `.md`.
  - Changes: GET `/leagues/:lid(\d+).md`, `/leagues/:lid(\d+)/rules.md`, `/leagues/:lid(\d+)/schedule.md`, `/leagues/:lid(\d+)/teams/:tid(\d+).md`, each importing and calling its generator directly, responding `Content-Type: text/markdown`; 404 on missing league/team AND on no-configured-season (map the generator's typed guard error); mount `api.use('/', context_docs)` after the static handlers and before the SPA catch-all.
  - Verify: a compiled-regex unit assertion that `/leagues/1.md` and `/leagues/123456789.md` match and `/leagues/1xmd` does not (no server boot); plus a route test asserting HTTP 200 `text/markdown` with a frontmatter block for a seeded league.

### Configuration & Setup

- [x] **Clipboard util + copy-markdown button**
  - File: `app/core/utils/copy-to-clipboard.js` (new), `app/views/components/copy-markdown-button/{index.js,copy-markdown-button.js,copy-markdown-button.styl}` (new)
  - Purpose: reusable copy action with success feedback.
  - Changes: `copy_to_clipboard(text)` wrapping `navigator.clipboard.writeText`; a generic `CopyMarkdownButton` (MUI `IconButton` + `ContentCopyOutlined`/`Check` 2s toggle) that takes a markdown path and derives the absolute URL from `BASE_URL`.
  - Verify: `yarn lint` clean; a component test asserts the derived URL for given `useParams` shapes (path-derived, not `window.location.href`).

- [x] **Wire buttons into team + league-home pages**
  - File: modify `app/views/pages/team/team.js`, `app/views/components/league-header/league-header.js`
  - Purpose: expose the copy action on the two pages.
  - Changes: team page passes a `head` to `PageLayout` containing `CopyMarkdownButton` with path `/leagues/:lid/teams/:tid.md` (from `useParams`); `league-header` renders the button beside the title with path `/leagues/:lid.md`.
  - Verify: `yarn build` succeeds; `yarn dev:live` (per `████████████████████████████████████`), navigate to a team page (including the tid-redirect case) and the league home, click the button, confirm the clipboard holds the correct absolute `.md` URL.

### Knowledge Base Updates

- [x] **In-repo system doc**
  - File: `docs/context-documents.md` (new); modify `README.md` key-docs table
  - Purpose: canonical description and discoverability.
  - Changes: document the four docs, the entity-vs-sub-view URL rule, the frontmatter/relation vocabulary, the self-sufficiency contract, the docs-vs-API-format boundary, and note the `context-docs/` dir name follows the repo's existing `docs/` shorthand; add a row to the README key-docs table.
  - Verify: `npx prettier --check docs/context-documents.md README.md`.

- [x] **ABOUT.md architecture observation**
  - File: `repository/active/league/ABOUT.md` (user-base entity)
  - Purpose: prevent future sessions from reinventing/breaking the contract.
  - Changes: add one `[architecture]` observation via `base entity observe` recording the human-path + `.md` serving, the self-sufficiency contract, and that the deep transaction log lives behind the separate API markdown-format task.
  - Verify: `base entity get user:repository/active/league/ABOUT.md` shows the observation.

### Testing & Validation

- [x] **Doc generation spec + lifecycle fixtures**
  - File: `test/context-docs.spec.mjs` (new)
  - Purpose: assert correctness, self-sufficiency, and routine-state handling against seeded fixtures.
  - Changes: generate each of the four docs for a fully-configured seeded league/team (frontmatter, required sections, cross-links); plus fixtures for no-season-row (guard → 404-mapped error), week-0/no-matchups (schedule + team schedule render the empty-state section), empty roster (team doc empty slot groups, full-cap), and an RFA-tagged player (cap uses `bid`).
  - Verify: `yarn test:local test/context-docs.spec.mjs` passes (PG16 throwaway per repo CLAUDE.md).

- [x] **Population-level self-sufficiency check**
  - File: `test/context-docs.spec.mjs`
  - Purpose: catch degenerate output that spot-checks would miss.
  - Changes: assert across the whole doc that (a) no raw numeric roster-slot code appears (every slot mapped), (b) every roster/transaction `pid` resolves to a rendered name (no bare pid strings), (c) the standings table row count equals the league team count, and (d) the schedule calendar contains a row for each populated field in the enumerated event set. Failure mode: an unresolved-label or missing-join regression that silently ships pid strings or numeric codes.
  - Verify: `yarn test:local test/context-docs.spec.mjs` passes; deliberately blanking a label-map entry fails the check.

- [x] **Route + serving integration check**
  - File: `test/context-docs.spec.mjs` (same spec, `supertest`-style against the Express app — not a direct handler call)
  - Purpose: confirm the four routes actually serve over HTTP.
  - Changes: boot the app and assert each of the four `.md` routes returns 200 `text/markdown`; assert a missing league and a no-season league both 404.
  - Verify: `yarn test:local` for the added cases passes.

- [x] **Full quality gate**
  - Purpose: repo-wide health before wrap.
  - Verify: `yarn lint`, `yarn build`, and `yarn test:local` (or `yarn test`) all pass; `git diff --name-only` matches the file list above (and does NOT include the six `league-settings-*` components or `api/routes/leagues/transactions.mjs` — those belong to the sibling tasks).