gdp-ts puts authorization requirements into TypeScript function signatures, but issue #11 reports passing a proof for one project while substituting another project's ID. That distinction drives this review: the pattern makes requirements visible to developers and agents, while the issue reports describe paths around its intended enforcement. Evaluate it as an additional development guardrail, with runtime policy checks and direct review of sensitive operations.
What people use gdp-ts for
The TypeScript 5.4+ library demonstrates a password-protection function requiring both a project-role proof and a plan-entitlement proof. The permission requirement appears in the sensitive function's signature rather than only in a route handler. A developer reading that signature can see which facts the caller needs to supply. The upstream README presents this as an application of Ghosts of Departed Proofs to TypeScript API contracts.
The documented pattern puts a runtime check inside a trusted module. That function looks up a user's role, for example, and returns a proof or null. The handler handles null, then passes the proof alongside a named project value. The intended contract connects those arguments. The application author writes the database query, chooses the permitted roles and implements the operation that consumes the proof.
The package also supplies ESLint and Oxlint presets and a Markdown skill for coding agents. The README explains that linting restricts assertions and proof creation outside trusted modules. For teams whose agents edit authorization-sensitive handlers, requiring a proof at the call site gives reviewers a specific contract to inspect alongside the check that produces it. The issue reports below describe failures in those intended restrictions.
| Who | What they did | Recorded outcome |
|---|---|---|
| Guillermo Rauch | Modeled changing a project password with role and entitlement proofs | The announcement describes README examples based on a real Vercel API constraint. Announcement extract |
| Aura Design System | Documented gdp-ts integration and starter authorization modules | Aura's synthesis record describes a project-deletion function demanding session, role and entitlement proofs. Integration record |
| Issue #11 reporter, identifying Pullfrog as reviewer | Evaluated gdp-ts in a production codebase | The reporter found that spreading a Named value could substitute another project ID. Evaluation report |
| Issue #5 and #7 reporters | Exercised real HTTP servers and deterministic password rotation in the examples | They reported malformed-input failures and a token issuance race. HTTP report, rotation report |
Aura's documentation describes naming session, user and project values before demanding the corresponding proofs. Its integration record also identifies default-preset wiring and starter authorization modules. This gives a team concrete responsibilities to map onto its application: authentication identifies the caller, a proof producer performs the relevant check, and the sensitive function requires the resulting evidence. The application still supplies the policy behind that evidence.
What happened when we ran it
Our November 13, 2026 repository run at commit 0b6ebee completed installation in 6 seconds, the build in 1 second and tests in 1 second. These are our recorded sandbox measurements. The repository harness used pnpm, and its results describe the checked-out repository and its tooling. The separate consumer quickstart installed the npm package and loaded a selected README declaration, so its installation figures belong to a different setup.
| Repository harness observation | Our recorded result |
|---|---|
| pnpm install | Succeeded in 6 seconds |
| Build | Succeeded in 1 second |
| Tests | Succeeded in 1 second |
| Dependencies | 180 recorded, 152 MB on disk |
| Checkout | 101 files, approximately 5,190 source lines, 0.6 MB |
| Configuration | 3 CPUs, 8 GB RAM, image label lab-node:22 |
| Repository signals | 2 CI workflow files, a tests directory, monorepo workspaces, no Dockerfile detected |
The consumer quickstart run used source reference 0b6ebeeec827 on November 13, 2026. It ran the quickstart-lib recipe in a fresh unprivileged lab-node:22 container configured with 2 CPUs and 4 GB RAM, with no published ports or secrets. Its task was the README's five-line JavaScript block from "The problem", selected because no install/usage section supplied a block for that task.
| Consumer quickstart question | Recorded answer | Verdict | Why |
|---|---|---|---|
| Did the clone step complete? | The quickstart-lib clone took 1 second. | Completed | The clone record records that duration. |
| Which package did installation select? | npm install @gdp-ts/core@latest installed @gdp-ts/core 0.1.0 in 12.5 seconds. | Completed | The installation record distinguishes the npm command from the README's pnpm command. |
| How much installed space did it record? | node_modules occupied 136 KB after installation. | Recorded | The installed-size record measures the consumer setup. |
| How many other packages were installed? | 0 packages besides @gdp-ts/core. | Recorded | The dependency-count record states that count. |
| What did the selected snippet do? | Node loaded the five-line declaration, exited 0 and produced no output in 0.1 seconds. | Declaration loaded | The snippet record identifies the README problem block. |
| Did teardown complete? | Teardown was recorded as ok. | Completed | The teardown record reports success. |
The selected snippet declares a handler containing an authorization check followed by a sensitive operation. Loading that declaration does not invoke the handler. This explains the successful exit with no output: the observed task was loading the README's problem example. The repository harness and consumer setup therefore provide separate setup observations, with the exact boundaries of those observations collected in the final section.
Where people get stuck: compiler settings and lint configuration
Issue #14 reports three documented compile errors disappearing when strictNullChecks or strictFunctionTypes is disabled. The cases are an unhandled nullable proof, a proof returned from a name callback and a proof about [never, never]. The README requires TypeScript 5.4 or newer; the report identifies compiler settings needed for those rejections. Review the effective configuration of each workspace alongside its compiler version.
| Report | What the reporter encountered | Action and recorded status |
|---|---|---|
| #14 | Unhandled nullable proofs and other documented errors compiled with strict checks disabled | Enable strict checking, including strictNullChecks and strictFunctionTypes. Configuration workaround; issue open in the pack. |
| #15 | Recipe-shaped proof interfaces and unused proof parameters triggered ESLint errors | Use the two rule overrides identified in examples/express-basic/eslint.config.js. Documentation workaround; issue open in the pack. |
| #3 | Static bracket access escaped proof-creation and exported-prover rules | Reporter identifies literal-property handling in isDefineProofCall as the required change. Proposed correction; issue open in the pack. |
| #16 | Local wildcard or renamed re-exports let other modules mint proofs | Reporter describes import detection missing the barrel path. Issue open in the pack. |
The recipe configuration report, issue #15, says ESLint exits 1 on code written as the recipe prescribes. The unused proof parameter triggers no-unused-vars, and the proof interface triggers no-empty-object-type. The reporter points to two targeted overrides in the Express example configuration. That gives adopters a specific configuration correction to inspect before responding to setup friction by disabling the authorization preset.
The bracket-access report, issue #3, describes static bracket access escaping the proof-creation and exported-prover rules. It also describes a computed-property detector using the property's spelling where its literal value is needed. The barrel report, issue #16, covers wildcard and renamed re-exports, which redirect imports through a local module. These reports concern particular detection paths rather than the appearance of the proof signature.
Security: a valid-looking proof can reach the wrong resource
Issue #11 reports that @gdp-ts/core 0.1.0 accepts a spread of Named that replaces its value while retaining the identity accepted by an existing proof. The reporter checked TypeScript 5.9.3 and the tsgo 7.0 native preview and describes acceptance without a type assertion or lint error. The Named-substitution report concerns the link between the checked project and the resource used by the sensitive operation.
The example first obtains an admin proof about one project. It then supplies an object spread from that project with its value replaced by another project's value. The proof still satisfies the signature in the report. The proposed repairs are a class with an ECMAScript private field or a lint rule against structural construction. Both target the reported substitution mechanism rather than only explicit casts.
Issue #13 reports proof substitutes passing typechecking and the strict preset under both ESLint and Oxlint. The expressions are null!, an implicitly any-typed value such as JSON.parse(payload).proof, and a never-typed value such as an empty-array indexed access. The strict-mode report says the sensitive function runs with the supplied value. Each expression bypasses the intended requirement to obtain a proof from an authorization check.
For adoption, review the runtime authorization path and denial behavior directly. Add compile-time expectations for missing proofs, then integration cases that attempt cross-resource access through the sensitive operation itself. Include proof constructors and their imports in that review. This recommendation follows the reported failure mechanisms: inspect both who may produce evidence and whether the operation receives the resource that the evidence concerns.
Proof freshness and HTTP errors still belong to the application
Issue #7 reports a password-version race inside one name callback at commit ebd0af9. The sequence validates the old password, changes it through an authorized path, then supplies the earlier proof to token issuance. The basic example returns a TokenUnlocksUrl proof, while the Drizzle example's real HTTP GET returns 200 instead of 401. The password-rotation report says both new regression tests fail.
According to the report, issuance reads the current passwordVersion rather than carrying the version originally checked. The proposed repair carries that checked version in PasswordAccepted so token checking can reject a token derived from the earlier password proof after rotation. The reporter calls this an example-level stale-proof race. Placing validation and issuance inside the same naming callback still permits the reported sequence of application mutations.
Issue #5 reports three malformed-input failures against the examples' real HTTP servers at ebd0af9. Malformed JSON returns 500 instead of 400; a body above Express's default 100 KB limit returns 500 instead of 413. In express-drizzle, a protection_token cookie containing a percent sign also returns 500 because decoding throws before the visit proof is checked. The HTTP error report records five failing regression tests: two in express-basic and three in express-drizzle.
The HTTP report identifies the generic internal-error handler as the destination for body-parser failures and asks for malformed cookie encoding to become a client error. These are concrete error-handling responsibilities around the proof contract. A handler can express its authorization requirements and still return the wrong HTTP status when parsing fails before the operation reaches that contract.
Scaling evidence concerns compiler work, not request throughput
Issue #9 reports that the benchmark runner prints FAILED and records a failed compiler run while returning process exit 0. Its reproduction supplies an invalid compiler target, then observes a compiler error and a failed result with a successful process status. The benchmark-runner report requests exit 1 whenever any target fails while preserving diagnostics. Read the recorded compiler outcome alongside the runner's process status.
The README advertises about 0.3 milliseconds per authorized call site on a cold TypeScript 7 check. That is the project's benchmark claim, separate from our repository setup measurements. A team evaluating compiler cost should measure its own codebase and inspect compiler diagnostics. The issue gives a concrete reason for that procedure: the reported runner lets a shell or CI job treat a failed benchmark as successful.
gdp-ts vs gdp-rs, policy engines and branded IDs
The upstream README describes gdp-ts as complementary to policy engines: an engine decides access, and a proof-producing function connects that decision to an operation. Its comparison also distinguishes branded IDs and schema validation from relationships between particular values. These are different application responsibilities. Choose according to the responsibility you need to implement, while considering the enforcement failures reported for the TypeScript proof contract.
| Option | What its cited description offers | Choose it when |
|---|---|---|
| gdp-ts | Named values and proof parameters in TypeScript | You want permission requirements visible in existing TypeScript APIs and will review the reported enforcement failures. |
| gdp-rs | Its author describes compiler-enforced module privacy and zero-sized proof types | You are building in Rust and accept lifetime errors as part of the design. Port README extract |
| CASL, Oso, Cerbos, Permit or OpenFGA | Policy decisions, according to the upstream comparison | You need to decide who can act. The README describes calling the chosen engine inside a proof function. |
| Branded IDs and schema validators | ID-kind distinctions and input-shape checking | Your immediate problem is mixing ID categories or accepting malformed data. The README describes using brands beneath named values. |
The gdp-rs author identifies lifetime-error complexity as a cost of its approach. Its async scopes use AsyncFnOnce closures, documented as requiring Rust 1.85 or newer. The gdp-rs extract describes names as lifetimes and explains that mistakes surface as lifetime errors. Those language-specific mechanisms make the port an architectural alternative for a Rust application rather than a package replacement within an existing TypeScript codebase.
For policy engines, the gdp-ts README comparison describes putting the access decision inside the function that produces a proof. It also distinguishes an ID's category from the particular value named by a callback. A schema checks input shape, a policy decides access, and the proof signature expresses the intended relationship at the call site. The reported bypasses matter when assessing enforcement of that last relationship.
What the other reviews get wrong
Issue #11 reports a counterexample to Aura's statement that a decision reaches the sensitive function about the right values. Aura's integration documentation uses guarantee language, while the issue describes substituting the Named value after obtaining a proof. This is more specific than a warning about TypeScript casts: the reporter's example uses neither a type assertion nor a lint error. Read the guarantee alongside the reported substitution mechanism.
Andrey Markin's directory says only the trusted module can create proofs. Issue #16 reports minting proofs through local re-exports while both linters stay silent. Hayden Bleasel's Ultracite post says creation outside proofs/ or leaking constructors triggers lint errors. Issue #3 reports static bracket-access calls escaping those rules. Compare the directory extract and preset announcement with the import and property-access paths described by the reporters.
The launch discussion's description of checks becoming unskippable conflicts with issue #13's accepted proof substitutes. Likewise, stating the TypeScript 5.4 minimum alone omits the compiler-option requirements reported in issue #14. These are evidence-qualified corrections to descriptions of the intended design: the issue reports identify accepted expressions and configuration-dependent behavior, rather than establishing a general conclusion about every application using the library.
The project is published as rauchg/gdp-ts, and Guillermo Rauch's announcement describes examples modeled on a real Vercel API constraint. That supports the password-protection use case and its role-plus-entitlement requirement. The announcement extract is the relevant source for those facts; the Doomers launch listing records attention around the announcement. Keep the repository's identity separate from the platform used to explain its example.
The scores rate setup and documentation within this scope
Setup earns 4/5, documentation 3/5 and maturity 2/5 under the rubric below. These are editorial judgments tied to the recorded setup and issue reports. The scale uses 1 for a blocking obstacle, 2 for substantial unresolved problems, 3 for a usable path needing material corrections, 4 for a demonstrated straightforward path and 5 for broad corroboration across the assessed scope. Community receives N/A.
The completed repository steps support the setup judgment. The README's explanation of naming, proof producers and sensitive signatures supports the documentation score, while issues #14 and #15 identify compiler and lint configuration corrections. The Named substitution, strict-preset proof substitutes and example token race support the maturity score. The rubric connects each judgment to a particular observation rather than converting repository attention into evidence of security.
GitHub metadata observed on November 14, 2026 records 855 stars, 25 open issues and pull requests combined, and a last push on October 26, 2026. The supplied latest-release value is null. These are repository activity observations. The community score is unassessed; the final section explains the evidence needed to rate that dimension and how to interpret the release lookup.
Questions people ask
The gdp-ts repository is rauchg/gdp-ts, and its README places role checks inside proof-producing functions. That separation gives maintainers a concrete place to inspect policy changes: the producer implements the rule, while callers supply its returned proof to the sensitive operation. The questions below cover the repository search intent, a reader's refactor question and issue #17's request for private security reporting.
Where is gdp-ts on GitHub?
The gdp-ts GitHub repository is rauchg/gdp-ts. Its README describes the core library, ESLint and Oxlint presets, coding-agent skill and example applications. Read the sensitive function signature alongside the trusted-module example: the signature states the required proof, while the producer contains the application's role check. Reading them together makes the proposed contract easier to evaluate than starting with the signature alone.
How do gdp-ts proofs survive refactors such as renaming a role constant?
The README puts the role check inside the trusted proof-producing function, while callers depend on its returned proof type. That makes the producer the concrete place to inspect when a role rule changes. Review its permitted-role comparison and exercise allowed and denied roles through the sensitive operation. A reader asks about proof behavior under refactors in the discussion record; the final section states the boundary of the available answer.
How can a security researcher report a gdp-ts vulnerability privately?
Issue #17 asks maintainers to provide a private reporting channel or contact. The reporter alleges a locally reproduced security issue and withholds technical details while requesting that route. The record shows the request as open with 0 comments. The reporting-channel request documents the request itself; the final section explains what the record supplies about submission instructions and the alleged issue.
What we have not tested yet
Our repository harness completed setup commands, and the consumer quickstart loaded a handler declaration; neither exercised a completed authorization workflow. We have not independently reproduced the Named substitution, lint escapes, compiler-option cases, token race or malformed-input reports against commit 0b6ebee. Their records concern @gdp-ts/core 0.1.0 or commit ebd0af9, with issue status captured by the pack. Proposed repairs receive no credit here as shipped fixes on our checkout.
The repository's 152 MB dependency footprint and the consumer setup's 136 KB node_modules observation cover different installations. Actual runtime and operating-system versions require raw toolchain logs; lab-node:22 is a configured image label. The harness supplies no test count or security-audit result. The consumer snippet's 0.1-second duration is not authorization latency. Request throughput, large-codebase typechecking cost and comparative performance remain outside our measurements, including the Rust port author's enforcement and runtime-cost claims.
Issue #13's reproduction leaves noUncheckedIndexedAccess unset, so it supplies no complete mitigation for the reported proof substitutes. The overview and integration records establish examples, scaffolding and evaluation rather than corroborated production security outcomes. The refactor discussion supplies no demonstrated role-rename result. Issue #17 supplies neither a private submission address nor public details establishing the alleged issue's severity or validity. Maintainer response times, all agent integrations and deployment in a real application also remain outside this review.
The launch material establishes examples modeled on a Vercel constraint rather than a generally available Vercel platform feature. The null latest-release value may reflect a failed lookup and establishes neither release absence nor abandonment. Rendered layout, assets, related links, recommendation modules and template content are outside this text review. For a pinned-version evaluation, exercise both sides of the contract: a valid check should permit the intended operation, and substituting another resource should still produce a denial.


