Skip to content

Latest commit

 

History

History
79 lines (65 loc) · 9.99 KB

limits.md

File metadata and controls

79 lines (65 loc) · 9.99 KB

Limits

What Forge cannot hold or do, in numbers, with where each number comes from. Some are Dash Platform's and some are Forge's own rules. The ones marked frozen are fixed once a network's contracts are registered (Deploying Forge to a network). If a push or a command fails, start with My first push failed.

  1. Sizes
  2. Text and counts
  3. What the apps read
  4. Pushes and the cost guard
  5. Not supported

Sizes

What Limit Source
One state transition (a signed write) 20,480 bytes (20 KiB) Platform's max_state_transition_size; ST_SIZE_LIMIT in crates/forge-core/src/pack.rs
One byte-array field 4,900 bytes (Platform's hard cap is 5,120; the rest is document overhead) FIELD_MAX in pack.rs
One chunk document (git pack bytes on Platform) 3 fields, 14,700 bytes of pack per chunk (about 14.4 KiB); a full chunk leaves at least 5 KiB for headers DOC_PAYLOAD_MAX in pack.rs
A pack 1 TiB: the cap on the size a manifest records (frozen). Forge's tools add no smaller cap; on Platform a pack is split over as many chunks as it needs, each costing about 0.005 DASH forge-v2.md §9; Costs
A contract (registration) 20,480 bytes, and at least 2,000 bytes of headroom under that for the create transition deploy-v2.mjs
A passkey vault entry (vaultEntry) credential id 16 to 255 bytes, recipient key 32, encapsulated key 32, sealed bundle 32 to 256 (Forge writes 256). An update can loosen the sealed bundle's bounds but never make it fixed-length, and cannot take the credential id past 255 bytes or version past 255 (frozen). One entry per identity and credential. Fees measured on testnet: about 43 to 52 million credits (about 0.0005 DASH) for an identity's first entry, 33 million for a later one, 3 million to re-seal; a delete refunds about 27 to 37 million, and a sign-in reads only forge-v2.md §2
A board (board, forge-meta) name 1 to 63 characters (252 bytes), definition 4,096 bytes of JSON, sealed 5,120 bytes; one definition per member and board. The board key stays a u32 and only maintainers and writers define boards (frozen); the size bounds can be loosened by an update. Fees measured on testnet: about 54 to 64 million credits for a new board with a template's definition, 3.4 to 4.6 million for an edit forge-v2.md §2; Boards
A card (card, forge-meta) column 0 to 255, rank 1 to 63 base-62 digits, field values 2,048 bytes of JSON, sealed 2,560 bytes; one card per member, item and board. A card always names an issue or a PR, and only the board's home repository's members write one (frozen). Fees measured on testnet: about 71 million credits for an item's first card, 89 million for a board's first, 43 million when another member has a card for the item, 4 to 5 million for a move same
Keys in a passkey vault entry at most 6: the main key (a group-bound limited key with a budget and an expiry), up to 4 per-contract wallet grants (each also with a budget and an expiry: an unlimited one stays on its device) and one encryption key (only if asked). At most 10 passkeys per identity Passkey vault
Pack download time each copy gets max(120 s, size ÷ 1 MiB/s); a manifest with no size allows 256 MiB Bring your own storage
Read-back check after an upload a full download and SHA-256 up to 16 MiB; larger packs get a size check and byte-exact head and tail ranges same
A history or flat index, inflated 64 MiB MAX_INFLATED in crates/forge-core/src/pack/historyindex.rs and flatindex.rs
One repack names at most 32 older packs it supersedes; run it again for the next ones Bring your own storage
A release asset uploaded from the browser 256 MiB per file Collaborating
A branch downloaded as a zip 100 MB, built in your browser Quick start

Text and counts

What Limit Source
An issue, comment or release-notes body 5,120 bytes on Platform (less in a private repository, where the title and other encrypted text share the space) Collaborating
A longer text up to 256 KiB, posted by a maintainer or writer; the field keeps its first part and names an artifact. Triage, Read and non-members stay within 5,120 bytes forge-v2.md §6.3
A members-only post 5,120 bytes less 61 bytes of envelope; a bot's reply is cut to at most 4,800 private-repos.md §23
An inline comment's diff hunk 1,024 bytes (it can be raised by an update, never lowered) forge-v2.md §9
A repository name 1 to 63 characters: lowercase letters, digits, ., _ and -, starting with a letter or digit (E202) docs/errors.md
Topics on a repository 20, each 1 to 30 characters (frozen) Collaborating
Protected-branch patterns 8 same
Required checks and their sources 10 (frozen) forge-v2.md §9
Reviewers asked from CODEOWNERS 15 Collaborating
People a message can go to 16, you included (an environment: 64) Who can read what
A bot's access note 500 characters; the AI service's name 100; a task for a bot 120 Bots and agents
A bot's push access at most 90 days (30 by default) Bots and agents
Names that differ only in case, or one the other as a folder (feature and feature/x) refused for branches and tags Collaborating

What the apps read

The apps read documents in pages and stop at a limit rather than guess. A result past a limit is marked, never silently wrong.

What Limit Effect
A repository's member-event feed 30 pages of 100: 3,000 events (FEED_MAX_PAGES in forge-web/lib/repo/issues.ts) Past it, label and assignee filters, pinned issues and milestone progress are shown as unverified. Hides, bans, labels, assignments and pins are events, so a very busy repository, or one that moderates a flood one post at a time, reaches it. Events cannot be deleted
Pull requests in a search the newest 100 Collaborating
Code search files over 384 KiB are skipped; at most 100 MiB of text; a repository over 2,000 files or 16 MiB stored is indexed on its default branch only Quick start
The history index each path's newest 256 first-parent versions Costs

Pushes and the cost guard

What Limit Source
A push that costs more than dash.costWarnThreshold, 0.05 DASH by default, asks first; with no terminal it stops with E801. The whole push counts, once, before anything is paid: every pack it stores and every ref update, deletes and tags at commits already stored too (git push --tags of 300 such tags costs about 0.28 DASH) Costs
Storing packs on Platform a push that would store more than 1 MiB of packs in all while dash.storage is unset asks first (they are permanent); raising the threshold does not lift this, choosing storage does E801
The key's budget a limited key spends at most its budget (0.25 DASH for dg auth new's key, 0.05 for a browser key by default) (E402) Identity and keys
Memory while indexing a fetched pack none unless you set dash.maxPackInput (the gateway sets one) Gateway
One identity writing from two places at once two writers can pick the same nonce; one write is dropped (E704) docs/errors.md

Not supported

  • Shallow clones (--depth, --shallow-since, --shallow-exclude) fail with E205. Use git clone --filter=blob:none for a smaller checkout (it saves disk, not download: see the next point).
  • A partial clone does not download less than a full one. A stored pack holds whole pushes, not single objects, so git clone --filter=blob:none reads every pack and keeps the commits and trees. The blobs git then fetches on demand (a checkout, git log -p, git blame) come only from the packs that hold them: the clone records which blobs each pack it read holds (.git/dash/catalog/). Every pack is still read again by a git fetch or git pull into a partial clone (a full clone reads only the new ones), by an on-demand fetch of a tree or commit (--filter=tree:0), and by one of a blob in a pack pushed since the clone last read every pack.
  • Atomic pushes (git push --atomic): each branch and tag is its own write.
  • Git LFS objects. A repository can hold LFS pointer files, but the large files are not stored: keep large binaries out of git, or attach them to releases.
  • A git older than 2.44 cannot clone histories with malformed author lines (E511).
  • Forks and webhooks of private repositories (E207).

What Forge leaves out by design or for later is in the FAQ.