mrkeyoor.comAsk

rauchg/gdp-tstested 13 Nov 2026commit 0b6ebee

gdp-ts review

gdp-ts is worth evaluating as a development guardrail for TypeScript teams that review trusted modules and retain runtime authorization checks.

  • README install 13 s
  • 136 KB on disk
6 sto install
  • 0 dependencies
  • Build 1 s
Dev Toolsevaluationupdated 14 Nov 2026
+3stars / 7d

gdp-ts is a TypeScript library, lint presets and an agent skill for expressing authorization and entitlement requirements in sensitive function signatures. The application supplies the policy and runtime check; supplied issue reports describe bypasses of the intended proof contract.

Verdict

gdp-ts is worth evaluating as a development guardrail for TypeScript teams that review trusted modules and retain runtime authorization checks. Our repository setup steps completed successfully, while supplied reports describe resource substitution, proof substitutes and lint escapes. Those reported failures rule out recommending the described proof and lint behavior as the sole boundary protecting a sensitive operation.

gdp-ts infographic: express authorization requirements in function signatures, plus our test result and who it suits
Tested 13 November 2026: the README snippet ran as written. Before that: source install 6 s, build 1 s; npm install took 13 s.

We ran it

Lab card: what happened when we ran gdp-ts
Lab card from our sandbox run
Screenshot of gdp-ts (github.com/rauchg/gdp-ts)
github.com/rauchg/gdp-ts
Install✓ · 6s180 packages · 152 MB
Build✓ · 1s
Tests✓ · 1sran, no count parsed
Repo101 files~5,190 lines of source · 0.6 MB · 2 CI workflows · tests dir

Answers from our run

Does gdp-ts build from source?

Dependencies installed in 6 seconds (180 packages), and the build succeeded in 1 seconds. We cloned commit 0b6ebee into a clean Debian container with 3 CPUs and no project-specific setup.

Do gdp-ts's tests pass?

Yes. The project's own test command exited successfully in 1 seconds, although its output did not expose an individual test count.

Who should not use gdp-ts?

Teams seeking a complete authorization boundary from compile success and strict lint: issues #11 and #13 report accepted bypasses.

What are the alternatives to gdp-ts?

gdp-rs, CASL, Zod. gdp-ts is worth evaluating as a development guardrail for TypeScript teams that review trusted modules and retain runtime authorization checks.

Setup5/5In our 2026-11-13 run it installed as the README says in 13 s and the README’s “The problem” example ran unedited.Editor’s note (scored 4/5): Under the visible rubric, the repository installation, build and test commands all completed successfully. This rates the recorded repository setup path.
Docs5/5The README has an install section (“Installation”) and a usage section (“Examples”), and its example ran as written in our 2026-11-13 run.Editor’s note (scored 3/5): The README explains naming, proof producers and sensitive signatures, while issues #14 and #15 identify compiler-option and lint-configuration corrections.
Community2/5Last push on 2026-10-26, 856 stars and maintainers answered or closed 0 of the 10 most-discussed issues we sampled.Editor’s note: The activity metadata and open reports provide no measured support response times or corroborated adoption outcomes.
Maturity1/5No tagged GitHub release, repository created 2026-10-04 and its test suite passed in our sandbox.Editor’s note (scored 2/5): The open reports describe Named substitution, strict-preset proof substitutes and an example token race, supporting substantial unresolved problems under the visible rubric.

How we score

Who it’s for

TypeScript teams making role and entitlement requirements visible in sensitive function signatures.
Engineers reviewing proof-producing modules alongside runtime authorization behavior.
Teams evaluating guardrails for agents that edit authorization-sensitive handlers.

Who it’s NOT for

Teams seeking a complete authorization boundary from compile success and strict lint: issues #11 and #13 report accepted bypasses.
Applications adopting the documented guarantees with strictNullChecks or strictFunctionTypes disabled: issue #14 reports documented errors compiling in that configuration.
Developers treating the password-token examples as finished security code: issue #7 reports a password-version race.

Setup reality

Our November 13, 2026 sandbox run at commit 0b6ebee completed pnpm installation in 6 seconds, the build in 1 second and tests in 1 second. It recorded 180 dependencies and 152 MB on disk, using a configured 3 CPUs, 8 GB RAM and image label lab-node:22.

The README requires TypeScript 5.4 or newer and documents ESLint and Oxlint presets. Issue #14 identifies strictNullChecks and strictFunctionTypes as additional prerequisites for several advertised compile errors. Issue #15 points to targeted lint overrides in the Express example configuration.

The separate consumer quickstart installed @gdp-ts/core 0.1.0 and loaded a five-line handler declaration without invoking it. Measurement boundaries appear in the final section.

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.

Alternatives

ProjectWhat it isPick it when
gdp-rsA Rust port whose author describes compiler-enforced module privacy and zero-sized proofs.Consider it for a Rust codebase where lifetime-based proof contracts fit the design; its author identifies lifetime errors as a learning cost.
CASLA policy-engine option named in the upstream comparison, which separates access decisions from proof contracts.Consider a policy engine when deciding who may act is the missing layer; the gdp-ts README describes calling that engine inside a proof-producing function.
ZodA validation library the README distinguishes from proofs about relationships between particular values.Consider input validation when the immediate task is checking data shape; resource authorization requires its own policy check.

Sources

  1. gdp-ts README
  2. Named substitution report
  3. Strict-lint bypass report
  4. Compiler requirements
  5. Aura integration
  6. gdp-rs port

More dev tools reviews