@opendatalabs/personal-server-ts-core 0.0.1-canary.00328bf

package/dist/pdpp/issuance.d.ts

@@ -0,0 +1,91 @@
+/**
+ * PDPP Core §7 grant issuance.
+ *
+ * Issuance is the moment every request-only convenience becomes a frozen fact.
+ * The guard that matters most here is staleness: §7 requires the AS to reject
+ * approval if instance eligibility or the reviewed revision changed between
+ * the owner seeing the review surface and the approval landing.
+ *
+ * We enforce that by recomputing the review digest from what we are about to
+ * issue and comparing it to the digest the owner approved. Any drift — a newly
+ * connected instance changing an auto-resolved handle, a re-fetched
+ * declaration, an edited field list — moves the digest and kills the approval.
+ * This is a re-derivation, not a stored-value comparison, so it catches drift
+ * in inputs that were never persisted alongside the approval.
+ */
+import { computeReviewDigest, type RequesterIdentity } from "./review.js";
+import { type InstanceInventory } from "./resolve.js";
+import { type DeclarationSnapshot, type Grant, type SelectionRequest } from "./types.js";
+export type IssuanceFailureCode = 
+/** The reviewed revision or instance eligibility moved before approval. */
+"stale_approval"
+/** purpose/ai_training without explicit affirmative consent. */
+ | "ai_training_consent_required" | "resolution_failed" | "access_denied";
+export interface IssuanceFailure {
+    code: IssuanceFailureCode;
+    message: string;
+}
+export type IssuanceResult = {
+    ok: true;
+    grant: Grant;
+    consentEvidence: ConsentEvidence;
+} | {
+    ok: false;
+    failure: IssuanceFailure;
+};
+/**
+ * Retained consent evidence. §6 requires the normalized exact client claims,
+ * with attribution, to be bound into the final approval artifact and preserved
+ * here — while staying outside the grant, introspection, and RS enforcement.
+ * Keeping them in a separate structure from `Grant` is what makes that
+ * separation structural rather than a convention someone can forget.
+ */
+export interface ConsentEvidence {
+    review_digest: string;
+    approved_at: string;
+    /** The exact snapshot identity consent was given against. */
+    declaration: {
+        source_id: string;
+        version: string;
+        digest: string;
+    };
+    client_claims?: {
+        attributed_to: string;
+        commitments: string[];
+    };
+    /** Recorded only for purpose codes that require it. */
+    explicit_ai_training_consent?: boolean;
+}
+export interface IssueGrantInput {
+    subjectId: string;
+    request: SelectionRequest;
+    /** The retained snapshot — the same one validation and review ran against. */
+    snapshot: DeclarationSnapshot;
+    /** Instance inventory as of *now*, re-read at approval time on purpose. */
+    inventory: InstanceInventory;
+    requester: RequesterIdentity;
+    /** The digest the owner actually approved. */
+    approvedReviewDigest: string;
+    /**
+     * Explicit affirmative consent for `purpose/ai_training`. Required only for
+     * that code (§6 AI training consent); ignored otherwise.
+     */
+    explicitAiTrainingConsent?: boolean;
+    /** AS-policy grant expiry. Absent means the grant never expires. */
+    expiresAt?: string;
+    streamDescriptions?: Record<string, string>;
+    now?: Date;
+}
+/**
+ * Resolve, re-verify the approval, and issue.
+ *
+ * Deliberately re-runs resolution against the *current* inventory rather than
+ * trusting the streams captured at review time. If the owner connected or
+ * disconnected an instance while the consent screen was open, resolution now
+ * produces different handles, the recomputed digest diverges, and we reject.
+ * Trusting the review-time streams would issue a grant the owner never saw.
+ */
+export declare function issueGrant(input: IssueGrantInput): IssuanceResult;
+/** Re-export so callers get the digest helper from the issuance seam. */
+export { computeReviewDigest };
+//# sourceMappingURL=issuance.d.ts.map

package/dist/pdpp/issuance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issuance.d.ts","sourceRoot":"","sources":["../../src/pdpp/issuance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAEL,mBAAmB,EAEnB,KAAK,iBAAiB,EACvB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAoB,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACxE,OAAO,EAGL,KAAK,mBAAmB,EACxB,KAAK,KAAK,EACV,KAAK,gBAAgB,EACtB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,mBAAmB;AAC7B,2EAA2E;AACzE,gBAAgB;AAClB,gEAAgE;GAC9D,8BAA8B,GAC9B,mBAAmB,GACnB,eAAe,CAAC;AAEpB,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,cAAc,GACtB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC;IAAC,eAAe,EAAE,eAAe,CAAA;CAAE,GAC5D;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,eAAe,CAAA;CAAE,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,WAAW,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACpE,aAAa,CAAC,EAAE;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACjE,uDAAuD;IACvD,4BAA4B,CAAC,EAAE,OAAO,CAAC;CACxC;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,8EAA8E;IAC9E,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,2EAA2E;IAC3E,SAAS,EAAE,iBAAiB,CAAC;IAC7B,SAAS,EAAE,iBAAiB,CAAC;IAC7B,8CAA8C;IAC9C,oBAAoB,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,oEAAoE;IACpE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,GAAG,CAAC,EAAE,IAAI,CAAC;CACZ;AAMD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,cAAc,CAwGjE;AAED,yEAAyE;AACzE,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/pdpp/issuance.js

@@ -0,0 +1,124 @@
+/**
+ * PDPP Core §7 grant issuance.
+ *
+ * Issuance is the moment every request-only convenience becomes a frozen fact.
+ * The guard that matters most here is staleness: §7 requires the AS to reject
+ * approval if instance eligibility or the reviewed revision changed between
+ * the owner seeing the review surface and the approval landing.
+ *
+ * We enforce that by recomputing the review digest from what we are about to
+ * issue and comparing it to the digest the owner approved. Any drift — a newly
+ * connected instance changing an auto-resolved handle, a re-fetched
+ * declaration, an edited field list — moves the digest and kills the approval.
+ * This is a re-derivation, not a stored-value comparison, so it catches drift
+ * in inputs that were never persisted alongside the approval.
+ */
+import { randomBytes } from "node:crypto";
+import { buildConsentReview, computeReviewDigest, normalizeClientClaims, } from "./review.js";
+import { resolveSelection } from "./resolve.js";
+import { AI_TRAINING_PURPOSE, PDPP_GRANT_VERSION, } from "./types.js";
+function newGrantId() {
+    return `grt_${randomBytes(12).toString("hex")}`;
+}
+/**
+ * Resolve, re-verify the approval, and issue.
+ *
+ * Deliberately re-runs resolution against the *current* inventory rather than
+ * trusting the streams captured at review time. If the owner connected or
+ * disconnected an instance while the consent screen was open, resolution now
+ * produces different handles, the recomputed digest diverges, and we reject.
+ * Trusting the review-time streams would issue a grant the owner never saw.
+ */
+export function issueGrant(input) {
+    const now = input.now ?? new Date();
+    if (input.request.purpose_code === AI_TRAINING_PURPOSE &&
+        input.explicitAiTrainingConsent !== true) {
+        return {
+            ok: false,
+            failure: {
+                code: "ai_training_consent_required",
+                message: "purpose/ai_training requires explicit affirmative consent before a grant may be issued",
+            },
+        };
+    }
+    const resolution = resolveSelection(input.request, input.snapshot, input.inventory);
+    if (!resolution.ok) {
+        return {
+            ok: false,
+            failure: {
+                code: "resolution_failed",
+                message: resolution.failure.message,
+            },
+        };
+    }
+    // Re-derive the review the owner would see from what we are about to issue.
+    const review = buildConsentReview({
+        subjectId: input.subjectId,
+        request: input.request,
+        snapshot: input.snapshot,
+        resolvedStreams: resolution.streams,
+        requester: input.requester,
+        expiresAt: input.expiresAt,
+        streamDescriptions: input.streamDescriptions,
+    });
+    if (review.review_digest !== input.approvedReviewDigest) {
+        return {
+            ok: false,
+            failure: {
+                code: "stale_approval",
+                message: "the reviewed selection or instance eligibility changed before approval; a new review is required",
+            },
+        };
+    }
+    const grant = {
+        version: PDPP_GRANT_VERSION,
+        grant_id: newGrantId(),
+        issued_at: now.toISOString(),
+        subject: { id: input.subjectId },
+        client: {
+            client_id: input.requester.client_id,
+            // §7: retained client_display is the AS-resolved identity, not raw
+            // inline input. `requester.display` already went through resolution.
+            ...(input.requester.display && {
+                client_display: input.requester.display,
+            }),
+        },
+        // Provenance comes from the accepted declaration, never from the request.
+        source: { kind: input.snapshot.source_kind, id: input.snapshot.source_id },
+        source_declaration: { version: input.snapshot.version },
+        purpose_code: input.request.purpose_code,
+        ...(input.request.purpose_description && {
+            purpose_description: input.request.purpose_description,
+        }),
+        access_mode: input.request.access_mode,
+        streams: resolution.streams,
+        ...(input.request.selection_preset && {
+            selection_preset: input.request.selection_preset,
+        }),
+        ...(input.request.retention && { retention: input.request.retention }),
+        ...(input.expiresAt && { expires_at: input.expiresAt }),
+    };
+    const normalizedClaims = normalizeClientClaims(input.request.client_claims);
+    const consentEvidence = {
+        review_digest: review.review_digest,
+        approved_at: now.toISOString(),
+        declaration: {
+            source_id: input.snapshot.source_id,
+            version: input.snapshot.version,
+            digest: input.snapshot.digest,
+        },
+        ...(normalizedClaims && {
+            client_claims: {
+                attributed_to: input.requester.display_name,
+                commitments: normalizedClaims,
+            },
+        }),
+        ...(input.request.purpose_code === AI_TRAINING_PURPOSE && {
+            explicit_ai_training_consent: true,
+        }),
+    };
+    return { ok: true, grant, consentEvidence };
+}
+/** Re-export so callers get the digest helper from the issuance seam. */
+export { computeReviewDigest };
+//# sourceMappingURL=issuance.js.map

package/dist/pdpp/issuance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"issuance.js","sourceRoot":"","sources":["../../src/pdpp/issuance.ts"],"names":[],"mappings":"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"}

package/dist/pdpp/pkce.d.ts

@@ -0,0 +1,53 @@
+/**
+ * PKCE (RFC 7636) for the PDPP authorization-code flow.
+ *
+ * PDPP clients are public clients: a browser app or a desktop tool holds no
+ * client secret, so `client_id` + `redirect_uri` alone do not prove that the
+ * party redeeming a code is the party that requested it. An attacker who
+ * intercepts the code — a malicious app registered on the same custom URI
+ * scheme, a leaked Referer, a shoulder-surfed loopback redirect — can redeem
+ * it and receive a grant-bound token. RFC 7636 §1 describes exactly this.
+ *
+ * PKCE closes it: the client sends a challenge up front and must present the
+ * verifier at redemption. The AS binds the two. An intercepted code is useless
+ * without the verifier, which never leaves the requesting client.
+ *
+ * Only S256 is supported. `plain` is in RFC 7636 for constrained clients that
+ * cannot compute SHA-256, and it defeats the purpose here: an attacker who
+ * sees the challenge in the authorization request has the verifier. RFC 7636
+ * §4.2 says a server MUST support S256 and clients MUST use it where they can;
+ * for a protocol carrying personal data there is no reason to accept the weak
+ * mode, so this AS declines `plain` explicitly rather than silently.
+ */
+/** The only challenge method this AS accepts. */
+export declare const PKCE_METHOD_S256 = "S256";
+/**
+ * base64url per RFC 7636 §appendix A: standard base64 with `+/` mapped to
+ * `-_` and padding stripped. Node's `base64url` encoding already does this.
+ */
+export declare function computeS256Challenge(verifier: string): string;
+export type PkceFailureCode = "missing_verifier" | "invalid_verifier" | "unsupported_method" | "missing_challenge";
+export interface PkceFailure {
+    code: PkceFailureCode;
+    message: string;
+}
+/**
+ * Validate a challenge at authorization time.
+ *
+ * Rejecting an unsupported method here, rather than at redemption, means a
+ * client learns its flow is unusable before the owner is asked to consent to
+ * anything — failing after consent would waste a real human decision.
+ */
+export declare function validateCodeChallenge(challenge: string | undefined, method: string | undefined, options: {
+    required: boolean;
+}): PkceFailure | null;
+/**
+ * Verify a presented verifier against the stored challenge at redemption.
+ *
+ * The comparison is constant-time. A challenge is not a secret in the way a
+ * password is — it is already public in the authorization request — but the
+ * verifier is, and an early-exit comparison over attacker-chosen input is a
+ * habit worth not forming in an authorization server.
+ */
+export declare function verifyCodeVerifier(verifier: string | undefined, storedChallenge: string | null, storedMethod: string | null): PkceFailure | null;
+//# sourceMappingURL=pkce.d.ts.map

package/dist/pdpp/pkce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pkce.d.ts","sourceRoot":"","sources":["../../src/pdpp/pkce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,iDAAiD;AACjD,eAAO,MAAM,gBAAgB,SAAS,CAAC;AAKvC;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED,MAAM,MAAM,eAAe,GACvB,kBAAkB,GAClB,kBAAkB,GAClB,oBAAoB,GACpB,mBAAmB,CAAC;AAExB,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE,GAC7B,WAAW,GAAG,IAAI,CAoBpB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,eAAe,EAAE,MAAM,GAAG,IAAI,EAC9B,YAAY,EAAE,MAAM,GAAG,IAAI,GAC1B,WAAW,GAAG,IAAI,CA8CpB"}

package/dist/pdpp/pkce.js

@@ -0,0 +1,109 @@
+/**
+ * PKCE (RFC 7636) for the PDPP authorization-code flow.
+ *
+ * PDPP clients are public clients: a browser app or a desktop tool holds no
+ * client secret, so `client_id` + `redirect_uri` alone do not prove that the
+ * party redeeming a code is the party that requested it. An attacker who
+ * intercepts the code — a malicious app registered on the same custom URI
+ * scheme, a leaked Referer, a shoulder-surfed loopback redirect — can redeem
+ * it and receive a grant-bound token. RFC 7636 §1 describes exactly this.
+ *
+ * PKCE closes it: the client sends a challenge up front and must present the
+ * verifier at redemption. The AS binds the two. An intercepted code is useless
+ * without the verifier, which never leaves the requesting client.
+ *
+ * Only S256 is supported. `plain` is in RFC 7636 for constrained clients that
+ * cannot compute SHA-256, and it defeats the purpose here: an attacker who
+ * sees the challenge in the authorization request has the verifier. RFC 7636
+ * §4.2 says a server MUST support S256 and clients MUST use it where they can;
+ * for a protocol carrying personal data there is no reason to accept the weak
+ * mode, so this AS declines `plain` explicitly rather than silently.
+ */
+import { createHash, timingSafeEqual } from "node:crypto";
+/** The only challenge method this AS accepts. */
+export const PKCE_METHOD_S256 = "S256";
+/** RFC 7636 §4.1: the verifier is 43–128 characters of unreserved ASCII. */
+const VERIFIER_RE = /^[A-Za-z0-9\-._~]{43,128}$/;
+/**
+ * base64url per RFC 7636 §appendix A: standard base64 with `+/` mapped to
+ * `-_` and padding stripped. Node's `base64url` encoding already does this.
+ */
+export function computeS256Challenge(verifier) {
+    return createHash("sha256").update(verifier, "ascii").digest("base64url");
+}
+/**
+ * Validate a challenge at authorization time.
+ *
+ * Rejecting an unsupported method here, rather than at redemption, means a
+ * client learns its flow is unusable before the owner is asked to consent to
+ * anything — failing after consent would waste a real human decision.
+ */
+export function validateCodeChallenge(challenge, method, options) {
+    if (challenge === undefined || challenge.length === 0) {
+        if (!options.required)
+            return null;
+        return {
+            code: "missing_challenge",
+            message: "code_challenge is required for the authorization code flow",
+        };
+    }
+    // An absent method defaults to `plain` under RFC 7636 §4.3. We do not accept
+    // plain, so an omitted method is an explicit error rather than a silent
+    // downgrade to the mode we refuse.
+    if (method !== PKCE_METHOD_S256) {
+        return {
+            code: "unsupported_method",
+            message: `code_challenge_method must be ${PKCE_METHOD_S256}; 'plain' is not accepted`,
+        };
+    }
+    return null;
+}
+/**
+ * Verify a presented verifier against the stored challenge at redemption.
+ *
+ * The comparison is constant-time. A challenge is not a secret in the way a
+ * password is — it is already public in the authorization request — but the
+ * verifier is, and an early-exit comparison over attacker-chosen input is a
+ * habit worth not forming in an authorization server.
+ */
+export function verifyCodeVerifier(verifier, storedChallenge, storedMethod) {
+    if (storedChallenge === null || storedChallenge.length === 0) {
+        // The code was issued without PKCE. Whether that is allowed is the
+        // authorization endpoint's decision (see `validateCodeChallenge`); by the
+        // time a code exists, there is nothing to verify against.
+        return null;
+    }
+    if (storedMethod !== PKCE_METHOD_S256) {
+        // A stored non-S256 method means the code was minted by a path that did
+        // not enforce the method check. Fail closed rather than honouring it.
+        return {
+            code: "unsupported_method",
+            message: "authorization code carries an unsupported code_challenge_method",
+        };
+    }
+    if (verifier === undefined || verifier.length === 0) {
+        return {
+            code: "missing_verifier",
+            message: "code_verifier is required to redeem this authorization code",
+        };
+    }
+    if (!VERIFIER_RE.test(verifier)) {
+        // Enforcing the shape stops a trivially-guessable short verifier from
+        // being accepted just because it happens to hash correctly.
+        return {
+            code: "invalid_verifier",
+            message: "code_verifier must be 43-128 characters of [A-Za-z0-9-._~] (RFC 7636 §4.1)",
+        };
+    }
+    const computed = computeS256Challenge(verifier);
+    const a = Buffer.from(computed, "utf8");
+    const b = Buffer.from(storedChallenge, "utf8");
+    if (a.length !== b.length || !timingSafeEqual(a, b)) {
+        return {
+            code: "invalid_verifier",
+            message: "code_verifier does not match the code_challenge",
+        };
+    }
+    return null;
+}
+//# sourceMappingURL=pkce.js.map

package/dist/pdpp/pkce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pkce.js","sourceRoot":"","sources":["../../src/pdpp/pkce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE1D,iDAAiD;AACjD,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC;AAEvC,4EAA4E;AAC5E,MAAM,WAAW,GAAG,4BAA4B,CAAC;AAEjD;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,QAAgB;IACnD,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;AAC5E,CAAC;AAaD;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CACnC,SAA6B,EAC7B,MAA0B,EAC1B,OAA8B;IAE9B,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtD,IAAI,CAAC,OAAO,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAC;QACnC,OAAO;YACL,IAAI,EAAE,mBAAmB;YACzB,OAAO,EAAE,4DAA4D;SACtE,CAAC;IACJ,CAAC;IAED,6EAA6E;IAC7E,wEAAwE;IACxE,mCAAmC;IACnC,IAAI,MAAM,KAAK,gBAAgB,EAAE,CAAC;QAChC,OAAO;YACL,IAAI,EAAE,oBAAoB;YAC1B,OAAO,EAAE,iCAAiC,gBAAgB,2BAA2B;SACtF,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAChC,QAA4B,EAC5B,eAA8B,EAC9B,YAA2B;IAE3B,IAAI,eAAe,KAAK,IAAI,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7D,mEAAmE;QACnE,0EAA0E;QAC1E,0DAA0D;QAC1D,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,YAAY,KAAK,gBAAgB,EAAE,CAAC;QACtC,wEAAwE;QACxE,sEAAsE;QACtE,OAAO;YACL,IAAI,EAAE,oBAAoB;YAC1B,OAAO,EACL,iEAAiE;SACpE,CAAC;IACJ,CAAC;IAED,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACpD,OAAO;YACL,IAAI,EAAE,kBAAkB;YACxB,OAAO,EAAE,6DAA6D;SACvE,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QAChC,sEAAsE;QACtE,4DAA4D;QAC5D,OAAO;YACL,IAAI,EAAE,kBAAkB;YACxB,OAAO,EACL,4EAA4E;SAC/E,CAAC;IACJ,CAAC;IAED,MAAM,QAAQ,GAAG,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IAChD,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACxC,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;IAC/C,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,IAAI,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;QACpD,OAAO;YACL,IAAI,EAAE,kBAAkB;YACxB,OAAO,EAAE,iDAAiD;SAC3D,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/pdpp/redirect.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Redirect URI validation (RFC 6749 §3.1.2, §10.6; RFC 8252 §7.3).
+ *
+ * The authorization code travels to the client in this redirect. If the AS
+ * honours whatever `redirect_uri` a caller supplies, the attack is direct: an
+ * attacker opens an authorization session pointing at their own host, the
+ * owner sees a consent screen that looks entirely legitimate (it is — the AS
+ * generated it), approves, and the code is delivered to the attacker.
+ *
+ * **PKCE does not mitigate this.** PKCE binds the code to whoever chose the
+ * challenge, and in this attack that is the attacker. They hold the matching
+ * verifier, so they redeem the stolen code and receive a grant-bound token
+ * over the owner's personal data. Code interception and code *misdelivery* are
+ * different problems; §10.6 is the one that covers misdelivery.
+ *
+ * Validation is by exact match against the client's registered redirect URIs.
+ * RFC 6749 §3.1.2.2 requires registration, and §3.1.2.3 allows fuzzier
+ * matching only for clients that registered a full URI — we do not take that
+ * latitude. Prefix or subdomain matching is where open-redirect bugs live: a
+ * registered `https://app.example.com/cb` "matching"
+ * `https://app.example.com.evil.test/cb` or `https://app.example.com/cb/../x`
+ * is the classic failure. Exact string equality after normalization has no
+ * such edge, and the cost is that a client registers each callback it uses.
+ */
+export type RedirectFailureCode = "unregistered_redirect_uri" | "insecure_redirect_uri" | "malformed_redirect_uri" | "no_registered_redirect_uris";
+export interface RedirectFailure {
+    code: RedirectFailureCode;
+    message: string;
+}
+/**
+ * Registered metadata for a client, as the deployment holds it.
+ *
+ * `redirect_uris` is required and non-empty for the code flow: a client with
+ * no registered callback cannot safely receive a code, and defaulting to
+ * "accept anything" would reintroduce exactly the hole this module closes.
+ */
+export interface RegisteredRedirectPolicy {
+    client_id: string;
+    redirect_uris: string[];
+}
+/**
+ * Validate a requested redirect URI against the client's registered set.
+ *
+ * Returns null when the URI is acceptable. Every rejection is deliberately
+ * the same shape, so a caller probing for registered URIs learns only that
+ * theirs was not one.
+ */
+export declare function validateRedirectUri(requested: string | undefined, policy: RegisteredRedirectPolicy | null): RedirectFailure | null;
+/**
+ * Whether a redirect failure may be reported *by redirecting*.
+ *
+ * RFC 6749 §4.1.2.1 is explicit: when the redirect URI is invalid or
+ * unregistered, the AS MUST NOT automatically redirect the user-agent to it.
+ * Doing so would turn the authorization endpoint into an open redirector and
+ * would hand the attacker the error response they were fishing for. Every
+ * failure from `validateRedirectUri` is therefore reported directly to the
+ * caller and never as a redirect.
+ */
+export declare const REDIRECT_FAILURES_ARE_NEVER_REDIRECTED: true;
+//# sourceMappingURL=redirect.d.ts.map

package/dist/pdpp/redirect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redirect.d.ts","sourceRoot":"","sources":["../../src/pdpp/redirect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAKH,MAAM,MAAM,mBAAmB,GAC3B,2BAA2B,GAC3B,uBAAuB,GACvB,wBAAwB,GACxB,6BAA6B,CAAC;AAElC,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAmBD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,MAAM,EAAE,wBAAwB,GAAG,IAAI,GACtC,eAAe,GAAG,IAAI,CAqExB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,sCAAsC,EAAG,IAAa,CAAC"}

package/dist/pdpp/redirect.js

@@ -0,0 +1,125 @@
+/**
+ * Redirect URI validation (RFC 6749 §3.1.2, §10.6; RFC 8252 §7.3).
+ *
+ * The authorization code travels to the client in this redirect. If the AS
+ * honours whatever `redirect_uri` a caller supplies, the attack is direct: an
+ * attacker opens an authorization session pointing at their own host, the
+ * owner sees a consent screen that looks entirely legitimate (it is — the AS
+ * generated it), approves, and the code is delivered to the attacker.
+ *
+ * **PKCE does not mitigate this.** PKCE binds the code to whoever chose the
+ * challenge, and in this attack that is the attacker. They hold the matching
+ * verifier, so they redeem the stolen code and receive a grant-bound token
+ * over the owner's personal data. Code interception and code *misdelivery* are
+ * different problems; §10.6 is the one that covers misdelivery.
+ *
+ * Validation is by exact match against the client's registered redirect URIs.
+ * RFC 6749 §3.1.2.2 requires registration, and §3.1.2.3 allows fuzzier
+ * matching only for clients that registered a full URI — we do not take that
+ * latitude. Prefix or subdomain matching is where open-redirect bugs live: a
+ * registered `https://app.example.com/cb` "matching"
+ * `https://app.example.com.evil.test/cb` or `https://app.example.com/cb/../x`
+ * is the classic failure. Exact string equality after normalization has no
+ * such edge, and the cost is that a client registers each callback it uses.
+ */
+/** Loopback hosts, where RFC 8252 §7.3 permits plain http for native apps. */
+const LOOPBACK_HOSTS = new Set(["127.0.0.1", "[::1]", "::1", "localhost"]);
+/**
+ * Normalize for comparison without loosening the match.
+ *
+ * `URL` resolves dot-segments and lowercases scheme and host, so
+ * `https://App.Example.com/cb/../cb` and `https://app.example.com/cb` compare
+ * equal — that is canonicalization, not fuzzy matching. Query and fragment are
+ * preserved, because a registered URI that carries a query is a different
+ * endpoint from one that does not.
+ */
+function normalize(raw) {
+    try {
+        return new URL(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Validate a requested redirect URI against the client's registered set.
+ *
+ * Returns null when the URI is acceptable. Every rejection is deliberately
+ * the same shape, so a caller probing for registered URIs learns only that
+ * theirs was not one.
+ */
+export function validateRedirectUri(requested, policy) {
+    if (!requested || requested.length === 0) {
+        return {
+            code: "malformed_redirect_uri",
+            message: "redirect_uri is required",
+        };
+    }
+    const url = normalize(requested);
+    if (!url) {
+        return {
+            code: "malformed_redirect_uri",
+            message: "redirect_uri is not a valid absolute URI",
+        };
+    }
+    // RFC 6749 §3.1.2: the endpoint URI MUST NOT include a fragment. A fragment
+    // is also how a target gets smuggled past a naive prefix check.
+    if (url.hash.length > 0) {
+        return {
+            code: "malformed_redirect_uri",
+            message: "redirect_uri must not include a fragment component",
+        };
+    }
+    // Scheme gate before anything else. `javascript:` and `data:` are the
+    // XSS-on-redirect shapes; everything non-http(s) is refused outright rather
+    // than enumerated, so a scheme nobody thought of is refused by default.
+    const isLoopback = LOOPBACK_HOSTS.has(url.hostname);
+    if (url.protocol === "http:") {
+        // RFC 8252 §7.3: loopback http is the native-app redirect, and is fine.
+        if (!isLoopback) {
+            return {
+                code: "insecure_redirect_uri",
+                message: "redirect_uri must use https except for loopback addresses",
+            };
+        }
+    }
+    else if (url.protocol !== "https:") {
+        return {
+            code: "insecure_redirect_uri",
+            message: `redirect_uri scheme '${url.protocol}' is not permitted`,
+        };
+    }
+    if (!policy || policy.redirect_uris.length === 0) {
+        // No registration means no safe target. Failing closed here is the whole
+        // point: an AS that falls back to "trust the request" when it has no
+        // policy has no policy.
+        return {
+            code: "no_registered_redirect_uris",
+            message: "client has no registered redirect URIs; register one before requesting authorization",
+        };
+    }
+    // Exact match after canonicalization. No prefix, no subdomain, no wildcard.
+    const matched = policy.redirect_uris.some((candidate) => {
+        const registered = normalize(candidate);
+        return registered !== null && registered.toString() === url.toString();
+    });
+    if (!matched) {
+        return {
+            code: "unregistered_redirect_uri",
+            message: "redirect_uri does not exactly match a registered redirect URI",
+        };
+    }
+    return null;
+}
+/**
+ * Whether a redirect failure may be reported *by redirecting*.
+ *
+ * RFC 6749 §4.1.2.1 is explicit: when the redirect URI is invalid or
+ * unregistered, the AS MUST NOT automatically redirect the user-agent to it.
+ * Doing so would turn the authorization endpoint into an open redirector and
+ * would hand the attacker the error response they were fishing for. Every
+ * failure from `validateRedirectUri` is therefore reported directly to the
+ * caller and never as a redirect.
+ */
+export const REDIRECT_FAILURES_ARE_NEVER_REDIRECTED = true;
+//# sourceMappingURL=redirect.js.map

package/dist/pdpp/redirect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redirect.js","sourceRoot":"","sources":["../../src/pdpp/redirect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,8EAA8E;AAC9E,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC,CAAC,WAAW,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC;AAyB3E;;;;;;;;GAQG;AACH,SAAS,SAAS,CAAC,GAAW;IAC5B,IAAI,CAAC;QACH,OAAO,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;IACtB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CACjC,SAA6B,EAC7B,MAAuC;IAEvC,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzC,OAAO;YACL,IAAI,EAAE,wBAAwB;YAC9B,OAAO,EAAE,0BAA0B;SACpC,CAAC;IACJ,CAAC;IAED,MAAM,GAAG,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC;IACjC,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,OAAO;YACL,IAAI,EAAE,wBAAwB;YAC9B,OAAO,EAAE,0CAA0C;SACpD,CAAC;IACJ,CAAC;IAED,4EAA4E;IAC5E,gEAAgE;IAChE,IAAI,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACxB,OAAO;YACL,IAAI,EAAE,wBAAwB;YAC9B,OAAO,EAAE,oDAAoD;SAC9D,CAAC;IACJ,CAAC;IAED,sEAAsE;IACtE,4EAA4E;IAC5E,wEAAwE;IACxE,MAAM,UAAU,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACpD,IAAI,GAAG,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;QAC7B,wEAAwE;QACxE,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,OAAO;gBACL,IAAI,EAAE,uBAAuB;gBAC7B,OAAO,EAAE,2DAA2D;aACrE,CAAC;QACJ,CAAC;IACH,CAAC;SAAM,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACrC,OAAO;YACL,IAAI,EAAE,uBAAuB;YAC7B,OAAO,EAAE,wBAAwB,GAAG,CAAC,QAAQ,oBAAoB;SAClE,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACjD,yEAAyE;QACzE,qEAAqE;QACrE,wBAAwB;QACxB,OAAO;YACL,IAAI,EAAE,6BAA6B;YACnC,OAAO,EACL,sFAAsF;SACzF,CAAC;IACJ,CAAC;IAED,4EAA4E;IAC5E,MAAM,OAAO,GAAG,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE;QACtD,MAAM,UAAU,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC;QACxC,OAAO,UAAU,KAAK,IAAI,IAAI,UAAU,CAAC,QAAQ,EAAE,KAAK,GAAG,CAAC,QAAQ,EAAE,CAAC;IACzE,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO;YACL,IAAI,EAAE,2BAA2B;YACjC,OAAO,EAAE,+DAA+D;SACzE,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,sCAAsC,GAAG,IAAa,CAAC"}

package/dist/pdpp/resolve.d.ts

@@ -0,0 +1,53 @@
+/**
+ * PDPP Core §6→§7 resolution: turn a validated selection request into the
+ * explicit grant facts that get frozen at issuance.
+ *
+ * Every request-only convenience dies here. Wildcards and presets expand to
+ * concrete stream rows, views resolve to field lists, omitted fields become
+ * the declaration's full field set, omitted instance handles resolve against
+ * the owner's connection inventory, and `time_range` freezes against the
+ * declaration's `consent_time_field`. §7 is explicit that none of these
+ * conveniences are continuing authority in the grant — the RS must never have
+ * to resolve anything, which is also what the AS→RS contract promises.
+ *
+ * Resolution runs against the same retained snapshot `selection.ts` validated
+ * against. Passing a newer declaration here is the bug §9 AS item 16 exists to
+ * prevent: it would let a later declaration widen an in-flight authorization.
+ */
+import { type DeclarationSnapshot, type SelectionRequest, type StreamGrant } from "./types.js";
+/**
+ * The owner's connected instances for a source, as the AS knows them at
+ * resolution time. §6 is strict that omitting `instance_ids` never means
+ * fan-in: the AS resolves exactly one eligible handle or requires an explicit
+ * owner choice.
+ */
+export interface InstanceInventory {
+    /** Eligible opaque handles for a given stream, in the owner's connection state. */
+    eligibleFor(streamName: string): string[];
+}
+export type ResolutionFailureCode = "unknown_stream" | "unknown_instance" | "instance_choice_required" | "no_eligible_instance" | "unknown_view" | "empty_field_set";
+export interface ResolutionFailure {
+    code: ResolutionFailureCode;
+    message: string;
+    /** The stream that could not be resolved, when the failure is stream-scoped. */
+    stream?: string;
+    /** For `instance_choice_required`: the handles the owner must choose between. */
+    candidates?: string[];
+}
+export type ResolutionResult = {
+    ok: true;
+    streams: StreamGrant[];
+} | {
+    ok: false;
+    failure: ResolutionFailure;
+};
+/**
+ * Resolve every enforcement axis for a validated selection request.
+ *
+ * Call this before showing the final approval surface: §7 requires the
+ * approval artifact to contain the exact resolved instance handles, stream
+ * names, fields, resources, and temporal bounds, which only exist once this
+ * has run.
+ */
+export declare function resolveSelection(request: SelectionRequest, snapshot: DeclarationSnapshot, inventory: InstanceInventory): ResolutionResult;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/pdpp/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/pdpp/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,KAAK,mBAAmB,EAExB,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAGjB,MAAM,YAAY,CAAC;AAEpB;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,mFAAmF;IACnF,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC3C;AAED,MAAM,MAAM,qBAAqB,GAC7B,gBAAgB,GAChB,kBAAkB,GAClB,0BAA0B,GAC1B,sBAAsB,GACtB,cAAc,GACd,iBAAiB,CAAC;AAEtB,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,qBAAqB,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iFAAiF;IACjF,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,MAAM,gBAAgB,GACxB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,WAAW,EAAE,CAAA;CAAE,GACpC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,iBAAiB,CAAA;CAAE,CAAC;AA6N9C;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,mBAAmB,EAC7B,SAAS,EAAE,iBAAiB,GAC3B,gBAAgB,CA0BlB"}