@yielded/jose 0.1.0-beta.19

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daniel van der Merwe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# @yielded/jose
+
+JOSE for Effect: JWK import/export, public key sets, compact signatures and
+encryption, and JWTs whose claims are encoded and decoded by your Effect Schema.
+Your application owns keys, accepted algorithms, issuers, audiences and token
+purpose. This package depends on `@yielded/crypto` and Effect, independently of Auth.
+
+```sh
+bun add @yielded/jose@beta @yielded/crypto@beta effect
+```
+
+Import `Jwk`, `Jwks`, `Jws`, `Jwt`, and `Jwe` from the root. Supply cryptographic
+services through an explicit crypto backend Layer. Local verification needs no
+HTTP; remote JWKS use an application-configured HTTPS URL and an Effect HttpClient,
+with a bounded cache and refresh lifetime owned by the Layer's Scope.
+
+Tokens, private keys, symmetric keys and decrypted bytes use `Redacted`. JWT
+verification checks the signature and registered claims before decoding your
+application Schema. Schema encoding/decoding failures and services remain in
+`E` and `R`; custom Schema diagnostics remain application-owned.
+`Jwt.decodeUnverified` only parses and never establishes trust.
+
+The initial profile is compact JWS/JWT with HS256, RS256, PS256, ES256 and EdDSA
+(Ed25519), and compact JWE with `dir` / `A256GCM`. Other algorithms, JSON
+serialization, unencoded/detached payloads, critical extensions and compression
+are unsupported. OAuth, discovery, sessions and account authority belong to
+other layers.
+
+See the [usage and profile reference](../../docs/src/content/docs/reference/jose.mdx)
+and the [shipped third-party notices](THIRD_PARTY_NOTICES.md).

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,53 @@
+# Third-party notices
+
+Selected public contract tests and the P-256 fixture in `test/` are adapted from
+[panva/jose](https://github.com/panva/jose/tree/505a55b8f73536082367b2614cb77e927ba96ec1),
+v6.2.12, commit `505a55b8f73536082367b2614cb77e927ba96ec1` (Filip Skokan).
+The selected source contracts are adapted to the supported profile:
+
+| Upstream tests                                                                                                                   | Local tests                                                                            |
+| -------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
+| `test/jws/compact.verify.test.ts`, `test/jws/flattened.verify.test.ts`, `test/jws/crit.test.ts`, `test/jws/restrictions.test.ts` | `test/protocols.test.ts`, `test/compact-validation.test.ts`, `test/key-policy.test.ts` |
+| `test/jwk/jwk2key.test.ts`, `test/jwk/key_input.test.ts`                                                                         | `test/key-policy.test.ts`, `test/protocols.test.ts`                                    |
+| `test/jwt/verify.test.ts`                                                                                                        | `test/claims.test.ts`, `test/jwt-verification.test.ts`                                 |
+| `test/jwks/local.test.ts`, `test/jwks/remote.test.ts`                                                                            | `test/jwks.test.ts`, `test/jwks-recovery.test.ts`, `test/fixtures.ts`                  |
+| `test/jwe/compact.encrypt.test.ts`, `test/jwe/compact.decrypt.test.ts`, `test/jwe/flattened.decrypt.test.ts`                     | `test/protocols.test.ts`, `test/compact-validation.test.ts`                            |
+
+Only applicable public behavior is adapted; flattened-format tests supply shared
+header and authentication-tag validation, not JSON serialization support. Tests
+use independent interoperation against that release, plus Effect-specific
+policy capture, scoped cancellation and bounded-waiter regressions. This is not
+a full upstream suite port or a claim of full upstream compatibility.
+
+The source implementation informs claim validation, protected-header policy, and
+key selection in `src/Jwt.ts`, `src/Jws.ts`, `src/Jwk.ts`, `src/Jwks.ts`, and
+`src/Jwe.ts`; these implementations are written for Effect services and Schema.
+No panva/jose runtime implementation is bundled or required.
+
+The wire formats follow RFC 7515, RFC 7516, RFC 7517, RFC 7518, RFC 7519,
+and RFC 8037; policy follows RFC 8725. No RFC code or example vectors are copied.
+Cryptographic primitives are supplied by `@yielded/crypto`, which ships its own notices.
+
+## panva/jose — MIT
+
+The MIT License (MIT)
+
+Copyright (c) 2018 Filip Skokan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/Errors.d.mts

@@ -0,0 +1,33 @@
+import { Schema } from "effect";
+import { OperationError } from "@yielded/crypto/Errors";
+//#region src/Errors.d.ts
+declare const InvalidToken_base: Schema.Class<InvalidToken, Schema.TaggedStruct<"JoseInvalidToken", {
+  readonly reason: Schema.Literals<readonly ["serialization", "header", "payload", "parameters"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Fixed diagnostics never include a token, claims, key, URL, or native cause. */
+export declare class InvalidToken extends InvalidToken_base {}
+declare const AlgorithmNotAllowed_base: Schema.Class<AlgorithmNotAllowed, Schema.TaggedStruct<"JoseAlgorithmNotAllowed", {}>, import("effect/Cause").YieldableError>;
+export declare class AlgorithmNotAllowed extends AlgorithmNotAllowed_base {}
+declare const InvalidKey_base: Schema.Class<InvalidKey, Schema.TaggedStruct<"JoseInvalidKey", {}>, import("effect/Cause").YieldableError>;
+export declare class InvalidKey extends InvalidKey_base {}
+declare const SignatureVerificationFailed_base: Schema.Class<SignatureVerificationFailed, Schema.TaggedStruct<"JoseSignatureVerificationFailed", {}>, import("effect/Cause").YieldableError>;
+export declare class SignatureVerificationFailed extends SignatureVerificationFailed_base {}
+declare const DecryptionFailed_base: Schema.Class<DecryptionFailed, Schema.TaggedStruct<"JoseDecryptionFailed", {}>, import("effect/Cause").YieldableError>;
+export declare class DecryptionFailed extends DecryptionFailed_base {}
+declare const KeyNotFound_base: Schema.Class<KeyNotFound, Schema.TaggedStruct<"JoseKeyNotFound", {}>, import("effect/Cause").YieldableError>;
+export declare class KeyNotFound extends KeyNotFound_base {}
+declare const AmbiguousKey_base: Schema.Class<AmbiguousKey, Schema.TaggedStruct<"JoseAmbiguousKey", {}>, import("effect/Cause").YieldableError>;
+export declare class AmbiguousKey extends AmbiguousKey_base {}
+declare const JwksUnavailable_base: Schema.Class<JwksUnavailable, Schema.TaggedStruct<"JoseJwksUnavailable", {
+  readonly reason: Schema.Literals<readonly ["configuration", "transport", "response", "cooldown", "busy", "closed"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class JwksUnavailable extends JwksUnavailable_base {}
+declare const ClaimValidationFailed_base: Schema.Class<ClaimValidationFailed, Schema.TaggedStruct<"JoseClaimValidationFailed", {
+  readonly claim: Schema.Literals<readonly ["registered", "iss", "sub", "aud", "exp", "nbf", "iat", "jti", "typ"]>;
+  readonly reason: Schema.Literals<readonly ["invalid", "missing", "mismatch", "expired", "notYetValid", "tooOld", "future"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ClaimValidationFailed extends ClaimValidationFailed_base {}
+export type KeyError = InvalidKey | KeyNotFound | AmbiguousKey | JwksUnavailable | OperationError;
+export type VerifyError = KeyError | InvalidToken | AlgorithmNotAllowed | SignatureVerificationFailed;
+//#endregion
+//# sourceMappingURL=Errors.d.mts.map

package/dist/Errors.mjs

@@ -0,0 +1,49 @@
+import { Schema } from "effect";
+//#region src/Errors.ts
+/** Fixed diagnostics never include a token, claims, key, URL, or native cause. */
+var InvalidToken = class extends Schema.TaggedError()("JoseInvalidToken", { reason: Schema.Literals([
+	"serialization",
+	"header",
+	"payload",
+	"parameters"
+]) }) {};
+var AlgorithmNotAllowed = class extends Schema.TaggedError()("JoseAlgorithmNotAllowed", {}) {};
+var InvalidKey = class extends Schema.TaggedError()("JoseInvalidKey", {}) {};
+var SignatureVerificationFailed = class extends Schema.TaggedError()("JoseSignatureVerificationFailed", {}) {};
+var DecryptionFailed = class extends Schema.TaggedError()("JoseDecryptionFailed", {}) {};
+var KeyNotFound = class extends Schema.TaggedError()("JoseKeyNotFound", {}) {};
+var AmbiguousKey = class extends Schema.TaggedError()("JoseAmbiguousKey", {}) {};
+var JwksUnavailable = class extends Schema.TaggedError()("JoseJwksUnavailable", { reason: Schema.Literals([
+	"configuration",
+	"transport",
+	"response",
+	"cooldown",
+	"busy",
+	"closed"
+]) }) {};
+var ClaimValidationFailed = class extends Schema.TaggedError()("JoseClaimValidationFailed", {
+	claim: Schema.Literals([
+		"registered",
+		"iss",
+		"sub",
+		"aud",
+		"exp",
+		"nbf",
+		"iat",
+		"jti",
+		"typ"
+	]),
+	reason: Schema.Literals([
+		"invalid",
+		"missing",
+		"mismatch",
+		"expired",
+		"notYetValid",
+		"tooOld",
+		"future"
+	])
+}) {};
+//#endregion
+export { AlgorithmNotAllowed, AmbiguousKey, ClaimValidationFailed, DecryptionFailed, InvalidKey, InvalidToken, JwksUnavailable, KeyNotFound, SignatureVerificationFailed };
+
+//# sourceMappingURL=Errors.mjs.map

package/dist/Errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.mjs","names":[],"sources":["../src/Errors.ts"],"sourcesContent":["import type { OperationError as CryptoError } from \"@yielded/crypto/Errors\";\nimport { Schema } from \"effect\";\n\n/** Fixed diagnostics never include a token, claims, key, URL, or native cause. */\nexport class InvalidToken extends Schema.TaggedError<InvalidToken>()(\"JoseInvalidToken\", {\n  reason: Schema.Literals([\"serialization\", \"header\", \"payload\", \"parameters\"]),\n}) {}\n\nexport class AlgorithmNotAllowed extends Schema.TaggedError<AlgorithmNotAllowed>()(\n  \"JoseAlgorithmNotAllowed\",\n  {},\n) {}\n\nexport class InvalidKey extends Schema.TaggedError<InvalidKey>()(\"JoseInvalidKey\", {}) {}\n\nexport class SignatureVerificationFailed extends Schema.TaggedError<SignatureVerificationFailed>()(\n  \"JoseSignatureVerificationFailed\",\n  {},\n) {}\n\nexport class DecryptionFailed extends Schema.TaggedError<DecryptionFailed>()(\n  \"JoseDecryptionFailed\",\n  {},\n) {}\n\nexport class KeyNotFound extends Schema.TaggedError<KeyNotFound>()(\"JoseKeyNotFound\", {}) {}\nexport class AmbiguousKey extends Schema.TaggedError<AmbiguousKey>()(\"JoseAmbiguousKey\", {}) {}\n\nexport class JwksUnavailable extends Schema.TaggedError<JwksUnavailable>()(\"JoseJwksUnavailable\", {\n  reason: Schema.Literals([\"configuration\", \"transport\", \"response\", \"cooldown\", \"busy\", \"closed\"]),\n}) {}\n\nexport class ClaimValidationFailed extends Schema.TaggedError<ClaimValidationFailed>()(\n  \"JoseClaimValidationFailed\",\n  {\n    claim: Schema.Literals([\"registered\", \"iss\", \"sub\", \"aud\", \"exp\", \"nbf\", \"iat\", \"jti\", \"typ\"]),\n    reason: Schema.Literals([\n      \"invalid\",\n      \"missing\",\n      \"mismatch\",\n      \"expired\",\n      \"notYetValid\",\n      \"tooOld\",\n      \"future\",\n    ]),\n  },\n) {}\n\nexport type KeyError = InvalidKey | KeyNotFound | AmbiguousKey | JwksUnavailable | CryptoError;\n\nexport type VerifyError =\n  | KeyError\n  | InvalidToken\n  | AlgorithmNotAllowed\n  | SignatureVerificationFailed;\n"],"mappings":";;;AAIA,IAAa,eAAb,cAAkC,OAAO,YAA0B,CAAC,CAAC,oBAAoB,EACvF,QAAQ,OAAO,SAAS;CAAC;CAAiB;CAAU;CAAW;AAAY,CAAC,EAC9E,CAAC,CAAC,CAAC,CAAC;AAEJ,IAAa,sBAAb,cAAyC,OAAO,YAAiC,CAAC,CAChF,2BACA,CAAC,CACH,CAAC,CAAC,CAAC;AAEH,IAAa,aAAb,cAAgC,OAAO,YAAwB,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;AAExF,IAAa,8BAAb,cAAiD,OAAO,YAAyC,CAAC,CAChG,mCACA,CAAC,CACH,CAAC,CAAC,CAAC;AAEH,IAAa,mBAAb,cAAsC,OAAO,YAA8B,CAAC,CAC1E,wBACA,CAAC,CACH,CAAC,CAAC,CAAC;AAEH,IAAa,cAAb,cAAiC,OAAO,YAAyB,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3F,IAAa,eAAb,cAAkC,OAAO,YAA0B,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC;AAE9F,IAAa,kBAAb,cAAqC,OAAO,YAA6B,CAAC,CAAC,uBAAuB,EAChG,QAAQ,OAAO,SAAS;CAAC;CAAiB;CAAa;CAAY;CAAY;CAAQ;AAAQ,CAAC,EAClG,CAAC,CAAC,CAAC,CAAC;AAEJ,IAAa,wBAAb,cAA2C,OAAO,YAAmC,CAAC,CACpF,6BACA;CACE,OAAO,OAAO,SAAS;EAAC;EAAc;EAAO;EAAO;EAAO;EAAO;EAAO;EAAO;EAAO;CAAK,CAAC;CAC7F,QAAQ,OAAO,SAAS;EACtB;EACA;EACA;EACA;EACA;EACA;EACA;CACF,CAAC;AACH,CACF,CAAC,CAAC,CAAC"}

package/dist/Jwe.d.mts

@@ -0,0 +1,35 @@
+import { DecryptionFailed, InvalidKey, InvalidToken } from "./Errors.mjs";
+import { SecretKey } from "./Jwk.mjs";
+import { Crypto, Effect, Redacted, Schema } from "effect";
+import { Aead } from "@yielded/crypto/Aead";
+import { OperationError } from "@yielded/crypto/Errors";
+//#region src/Jwe.d.ts
+export declare const Header: Schema.Struct<{
+  readonly alg: Schema.Literal<"dir">;
+  readonly enc: Schema.Literal<"A256GCM">;
+  readonly kid: Schema.optionalKey<Schema.String>;
+  readonly typ: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly cty: Schema.optionalKey<Schema.NonEmptyString>;
+}>;
+export type Header = typeof Header.Type;
+export type JweError = InvalidToken | InvalidKey | OperationError | DecryptionFailed;
+/** Generates a fresh 96-bit IV; random-source failures become CryptoUnavailable. */
+export declare const encrypt: (plaintext: Redacted.Redacted<Uint8Array<ArrayBufferLike>>, key: SecretKey, input: {
+  readonly alg: "dir";
+  readonly enc: "A256GCM";
+  readonly kid?: string;
+  readonly typ?: string;
+  readonly cty?: string;
+}) => Effect.Effect<Redacted.Redacted<string>, JweError, Aead | Crypto.Crypto>;
+export declare const decrypt: (token: Redacted.Redacted<string>, key: SecretKey) => Effect.Effect<{
+  protectedHeader: {
+    readonly alg: "dir";
+    readonly enc: "A256GCM";
+    readonly kid?: string;
+    readonly typ?: string;
+    readonly cty?: string;
+  };
+  plaintext: Redacted.Redacted<Uint8Array<ArrayBufferLike>>;
+}, DecryptionFailed | InvalidKey | InvalidToken | OperationError, Aead>;
+//#endregion
+//# sourceMappingURL=Jwe.d.mts.map

package/dist/Jwe.mjs

@@ -0,0 +1,66 @@
+import { DecryptionFailed, InvalidKey, InvalidToken } from "./Errors.mjs";
+import { JsonObject, decode, json, parse, reveal, split, stringify, utf8 } from "./internal/encoding.mjs";
+import { check } from "./internal/keyPolicy.mjs";
+import { Crypto, Effect, Redacted, Schema } from "effect";
+import { Base64Url } from "effect/encoding";
+import { Aead } from "@yielded/crypto/Aead";
+import { CryptoUnavailable } from "@yielded/crypto/Errors";
+//#region src/Jwe.ts
+const Header = Schema.Struct({
+	alg: Schema.Literal("dir"),
+	enc: Schema.Literal("A256GCM"),
+	kid: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(256))),
+	typ: Schema.optionalKey(Schema.NonEmptyString),
+	cty: Schema.optionalKey(Schema.NonEmptyString)
+});
+const readHeader = Effect.fnUntraced(function* (input) {
+	const raw = yield* parse(JsonObject, input, "header");
+	if (raw.crit !== void 0 || raw.zip !== void 0) return yield* InvalidToken.make({ reason: "header" });
+	return yield* parse(Header, raw, "header");
+});
+/** Generates a fresh 96-bit IV; random-source failures become CryptoUnavailable. */
+const encrypt = Effect.fnUntraced(function* (plaintext, key, input) {
+	const header = yield* readHeader(input);
+	if (key.algorithm !== "dir") return yield* InvalidKey.make({});
+	yield* check(yield* reveal(key.jwk), "dir", "encrypt");
+	yield* parse(Schema.Uint8Array.check(Schema.isMaxLength(45e3)), yield* reveal(plaintext), "payload");
+	const protectedPart = Base64Url.encode(yield* stringify(header).pipe(Effect.mapError(() => InvalidToken.make({ reason: "header" }))));
+	if (protectedPart.length > 4096) return yield* InvalidToken.make({ reason: "header" });
+	const nonce = yield* (yield* Crypto.Crypto).randomBytes(12).pipe(Effect.mapError(() => CryptoUnavailable.make({})));
+	const sealed = yield* (yield* Aead).encrypt({
+		algorithm: "AES-256-GCM",
+		key: key.material,
+		nonce,
+		plaintext,
+		additionalData: utf8(protectedPart)
+	});
+	return Redacted.make(`${protectedPart}..${Base64Url.encode(nonce)}.${Base64Url.encode(sealed.subarray(0, -16))}.${Base64Url.encode(sealed.subarray(-16))}`);
+});
+const decrypt = Effect.fnUntraced(function* (token, key) {
+	const [protectedPart, encryptedKey, iv, ciphertext, tag] = yield* split(token, 5);
+	if (encryptedKey !== "" || protectedPart.length > 4096) return yield* InvalidToken.make({ reason: "serialization" });
+	const protectedHeader = yield* readHeader(yield* json(yield* decode(protectedPart), "header"));
+	if (key.algorithm !== "dir") return yield* InvalidKey.make({});
+	yield* check(yield* reveal(key.jwk), "dir", "decrypt");
+	const nonce = yield* decode(iv);
+	const data = yield* decode(ciphertext);
+	const authTag = yield* decode(tag);
+	if (nonce.length !== 12 || authTag.length !== 16) return yield* InvalidToken.make({ reason: "serialization" });
+	const sealed = new Uint8Array(data.length + authTag.length);
+	sealed.set(data);
+	sealed.set(authTag, data.length);
+	return {
+		protectedHeader,
+		plaintext: yield* (yield* Aead).decrypt({
+			algorithm: "AES-256-GCM",
+			key: key.material,
+			nonce,
+			ciphertext: sealed,
+			additionalData: utf8(protectedPart)
+		}).pipe(Effect.catchTag("CryptoAuthenticationFailed", () => DecryptionFailed.make({})))
+	};
+});
+//#endregion
+export { Header, decrypt, encrypt };
+
+//# sourceMappingURL=Jwe.mjs.map

package/dist/Jwe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Jwe.mjs","names":["KeyPolicy.check"],"sources":["../src/Jwe.ts"],"sourcesContent":["import { Aead } from \"@yielded/crypto/Aead\";\nimport { CryptoUnavailable, type OperationError } from \"@yielded/crypto/Errors\";\nimport { Crypto, Effect, Redacted, Schema } from \"effect\";\nimport { Base64Url } from \"effect/encoding\";\n\nimport { DecryptionFailed, InvalidKey, InvalidToken } from \"./Errors\";\nimport {\n  decode,\n  json,\n  JsonObject,\n  parse,\n  reveal,\n  split,\n  stringify,\n  utf8,\n} from \"./internal/encoding\";\nimport * as KeyPolicy from \"./internal/keyPolicy\";\nimport type { SecretKey } from \"./Jwk\";\n\nexport const Header = Schema.Struct({\n  alg: Schema.Literal(\"dir\"),\n  enc: Schema.Literal(\"A256GCM\"),\n  kid: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(256))),\n  typ: Schema.optionalKey(Schema.NonEmptyString),\n  cty: Schema.optionalKey(Schema.NonEmptyString),\n});\n\nexport type Header = typeof Header.Type;\nexport type JweError = InvalidToken | InvalidKey | OperationError | DecryptionFailed;\n\nconst readHeader = Effect.fnUntraced(function* (input: unknown) {\n  const raw = yield* parse(JsonObject, input, \"header\");\n\n  if (raw.crit !== undefined || raw.zip !== undefined)\n    return yield* InvalidToken.make({ reason: \"header\" });\n\n  return yield* parse(Header, raw, \"header\");\n});\n\n/** Generates a fresh 96-bit IV; random-source failures become CryptoUnavailable. */\nexport const encrypt = Effect.fnUntraced(function* (\n  plaintext: Redacted.Redacted<Uint8Array>,\n  key: SecretKey,\n  input: Header,\n): Effect.fn.Return<Redacted.Redacted<string>, JweError, Aead | Crypto.Crypto> {\n  const header = yield* readHeader(input);\n\n  if (key.algorithm !== \"dir\") return yield* InvalidKey.make({});\n  yield* KeyPolicy.check(yield* reveal(key.jwk), \"dir\", \"encrypt\");\n  yield* parse(\n    Schema.Uint8Array.check(Schema.isMaxLength(45000)),\n    yield* reveal(plaintext),\n    \"payload\",\n  );\n\n  const protectedPart = Base64Url.encode(\n    yield* stringify(header).pipe(Effect.mapError(() => InvalidToken.make({ reason: \"header\" }))),\n  );\n\n  if (protectedPart.length > 4096) return yield* InvalidToken.make({ reason: \"header\" });\n  const random = yield* Crypto.Crypto;\n\n  const nonce = yield* random\n    .randomBytes(12)\n    .pipe(Effect.mapError(() => CryptoUnavailable.make({})));\n\n  const aead = yield* Aead;\n\n  const sealed = yield* aead.encrypt({\n    algorithm: \"AES-256-GCM\",\n    key: key.material,\n    nonce,\n    plaintext,\n    additionalData: utf8(protectedPart),\n  });\n\n  return Redacted.make(\n    `${protectedPart}..${Base64Url.encode(nonce)}.${Base64Url.encode(sealed.subarray(0, -16))}.${Base64Url.encode(sealed.subarray(-16))}`,\n  );\n});\n\nexport const decrypt = Effect.fnUntraced(function* (\n  token: Redacted.Redacted<string>,\n  key: SecretKey,\n) {\n  const [protectedPart, encryptedKey, iv, ciphertext, tag] = yield* split(token, 5);\n\n  if (encryptedKey !== \"\" || protectedPart.length > 4096)\n    return yield* InvalidToken.make({ reason: \"serialization\" });\n  const protectedHeader = yield* readHeader(yield* json(yield* decode(protectedPart), \"header\"));\n\n  if (key.algorithm !== \"dir\") return yield* InvalidKey.make({});\n  yield* KeyPolicy.check(yield* reveal(key.jwk), \"dir\", \"decrypt\");\n  const nonce = yield* decode(iv);\n  const data = yield* decode(ciphertext);\n  const authTag = yield* decode(tag);\n\n  if (nonce.length !== 12 || authTag.length !== 16)\n    return yield* InvalidToken.make({ reason: \"serialization\" });\n  const sealed = new Uint8Array(data.length + authTag.length);\n\n  sealed.set(data);\n  sealed.set(authTag, data.length);\n  const aead = yield* Aead;\n\n  const plaintext = yield* aead\n    .decrypt({\n      algorithm: \"AES-256-GCM\",\n      key: key.material,\n      nonce,\n      ciphertext: sealed,\n      additionalData: utf8(protectedPart),\n    })\n    .pipe(Effect.catchTag(\"CryptoAuthenticationFailed\", () => DecryptionFailed.make({})));\n\n  return { protectedHeader, plaintext };\n});\n"],"mappings":"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"}

package/dist/Jwk.d.mts

@@ -0,0 +1,273 @@
+import { InvalidKey } from "./Errors.mjs";
+import { Effect, Redacted, Schema } from "effect";
+import * as Signature$1 from "@yielded/crypto/Signature";
+//#region src/Jwk.d.ts
+export declare const AsymmetricAlgorithm: Schema.Literals<readonly ["RS256", "PS256", "ES256", "EdDSA"]>;
+export type AsymmetricAlgorithm = typeof AsymmetricAlgorithm.Type;
+export declare const Algorithm: Schema.Literals<readonly ["HS256", "RS256", "PS256", "ES256", "EdDSA"]>;
+export type Algorithm = typeof Algorithm.Type;
+export declare const PublicJwk: Schema.Union<readonly [Schema.Struct<{
+  readonly kid: Schema.optionalKey<Schema.String>;
+  readonly alg: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly use: Schema.optionalKey<Schema.Literals<readonly ["sig", "enc"]>>;
+  readonly key_ops: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+  readonly kty: Schema.Literal<"RSA">;
+  readonly n: Schema.String;
+  readonly e: Schema.String;
+  readonly d: Schema.optionalKey<Schema.Never>;
+  readonly k: Schema.optionalKey<Schema.Never>;
+}>, Schema.Struct<{
+  readonly kid: Schema.optionalKey<Schema.String>;
+  readonly alg: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly use: Schema.optionalKey<Schema.Literals<readonly ["sig", "enc"]>>;
+  readonly key_ops: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+  readonly kty: Schema.Literal<"EC">;
+  readonly crv: Schema.Literal<"P-256">;
+  readonly x: Schema.String;
+  readonly y: Schema.String;
+  readonly d: Schema.optionalKey<Schema.Never>;
+  readonly k: Schema.optionalKey<Schema.Never>;
+}>, Schema.Struct<{
+  readonly kid: Schema.optionalKey<Schema.String>;
+  readonly alg: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly use: Schema.optionalKey<Schema.Literals<readonly ["sig", "enc"]>>;
+  readonly key_ops: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+  readonly kty: Schema.Literal<"OKP">;
+  readonly crv: Schema.Literal<"Ed25519">;
+  readonly x: Schema.String;
+  readonly d: Schema.optionalKey<Schema.Never>;
+  readonly k: Schema.optionalKey<Schema.Never>;
+}>]>;
+export type PublicJwk = typeof PublicJwk.Type;
+export declare const PrivateJwk: Schema.Union<readonly [Schema.Struct<{
+  readonly kid: Schema.optionalKey<Schema.String>;
+  readonly alg: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly use: Schema.optionalKey<Schema.Literals<readonly ["sig", "enc"]>>;
+  readonly key_ops: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+  readonly kty: Schema.Literal<"RSA">;
+  readonly n: Schema.String;
+  readonly e: Schema.String;
+  readonly d: Schema.String;
+  readonly p: Schema.String;
+  readonly q: Schema.String;
+  readonly dp: Schema.String;
+  readonly dq: Schema.String;
+  readonly qi: Schema.String;
+  readonly oth: Schema.optionalKey<Schema.Never>;
+}>, Schema.Struct<{
+  readonly kid: Schema.optionalKey<Schema.String>;
+  readonly alg: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly use: Schema.optionalKey<Schema.Literals<readonly ["sig", "enc"]>>;
+  readonly key_ops: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+  readonly kty: Schema.Literal<"EC">;
+  readonly crv: Schema.Literal<"P-256">;
+  readonly x: Schema.String;
+  readonly y: Schema.String;
+  readonly d: Schema.String;
+}>, Schema.Struct<{
+  readonly kid: Schema.optionalKey<Schema.String>;
+  readonly alg: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly use: Schema.optionalKey<Schema.Literals<readonly ["sig", "enc"]>>;
+  readonly key_ops: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+  readonly kty: Schema.Literal<"OKP">;
+  readonly crv: Schema.Literal<"Ed25519">;
+  readonly x: Schema.String;
+  readonly d: Schema.String;
+}>]>;
+export type PrivateJwk = typeof PrivateJwk.Type;
+export declare const SecretJwk: Schema.Struct<{
+  readonly kid: Schema.optionalKey<Schema.String>;
+  readonly alg: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly use: Schema.optionalKey<Schema.Literals<readonly ["sig", "enc"]>>;
+  readonly key_ops: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+  readonly kty: Schema.Literal<"oct">;
+  readonly k: Schema.String;
+}>;
+export type SecretJwk = typeof SecretJwk.Type;
+/** Validated, algorithm-bound key snapshots. Private material remains Redacted. */
+export interface PublicKey {
+  readonly _tag: "PublicKey";
+  readonly algorithm: AsymmetricAlgorithm;
+  readonly jwk: PublicJwk;
+  readonly material: Uint8Array;
+}
+export interface PrivateKey {
+  readonly _tag: "PrivateKey";
+  readonly algorithm: AsymmetricAlgorithm;
+  readonly jwk: Redacted.Redacted<PrivateJwk>;
+  readonly material: Redacted.Redacted<Uint8Array>;
+}
+export interface SecretKey {
+  readonly _tag: "SecretKey";
+  readonly algorithm: "HS256" | "dir";
+  readonly jwk: Redacted.Redacted<SecretJwk>;
+  readonly material: Redacted.Redacted<Uint8Array>;
+}
+export type SigningKey = PrivateKey | SecretKey;
+export type VerificationKey = PublicKey | SecretKey;
+export declare const importPublic: (input: unknown, selected: "ES256" | "EdDSA" | "PS256" | "RS256") => Effect.Effect<Readonly<{
+  _tag: "PublicKey";
+  algorithm: "ES256" | "EdDSA" | "PS256" | "RS256";
+  jwk: {
+    readonly kid?: string;
+    readonly alg?: string;
+    readonly use?: "enc" | "sig";
+    readonly key_ops?: readonly string[];
+    readonly kty: "RSA";
+    readonly n: string;
+    readonly e: string;
+    readonly d?: never;
+    readonly k?: never;
+  } | {
+    readonly kid?: string;
+    readonly alg?: string;
+    readonly use?: "enc" | "sig";
+    readonly key_ops?: readonly string[];
+    readonly kty: "EC";
+    readonly crv: "P-256";
+    readonly x: string;
+    readonly y: string;
+    readonly d?: never;
+    readonly k?: never;
+  } | {
+    readonly kid?: string;
+    readonly alg?: string;
+    readonly use?: "enc" | "sig";
+    readonly key_ops?: readonly string[];
+    readonly kty: "OKP";
+    readonly crv: "Ed25519";
+    readonly x: string;
+    readonly d?: never;
+    readonly k?: never;
+  };
+  material: Uint8Array<ArrayBufferLike>;
+}>, import("@yielded/crypto/Errors").CryptoUnavailable | InvalidKey | import("@yielded/crypto/Errors").UnsupportedAlgorithm, Signature$1.Signature>;
+export declare const importPrivate: (input: Redacted.Redacted<unknown>, selected: "ES256" | "EdDSA" | "PS256" | "RS256") => Effect.Effect<Readonly<{
+  _tag: "PrivateKey";
+  algorithm: "ES256" | "EdDSA" | "PS256" | "RS256";
+  jwk: Redacted.Redacted<{
+    readonly kid?: string;
+    readonly alg?: string;
+    readonly use?: "enc" | "sig";
+    readonly key_ops?: readonly string[];
+    readonly kty: "RSA";
+    readonly n: string;
+    readonly e: string;
+    readonly d: string;
+    readonly p: string;
+    readonly q: string;
+    readonly dp: string;
+    readonly dq: string;
+    readonly qi: string;
+    readonly oth?: never;
+  } | {
+    readonly kid?: string;
+    readonly alg?: string;
+    readonly use?: "enc" | "sig";
+    readonly key_ops?: readonly string[];
+    readonly kty: "EC";
+    readonly crv: "P-256";
+    readonly x: string;
+    readonly y: string;
+    readonly d: string;
+  } | {
+    readonly kid?: string;
+    readonly alg?: string;
+    readonly use?: "enc" | "sig";
+    readonly key_ops?: readonly string[];
+    readonly kty: "OKP";
+    readonly crv: "Ed25519";
+    readonly x: string;
+    readonly d: string;
+  }>;
+  material: Redacted.Redacted<Uint8Array<ArrayBufferLike>>;
+}>, import("@yielded/crypto/Errors").CryptoUnavailable | InvalidKey | import("@yielded/crypto/Errors").UnsupportedAlgorithm, Signature$1.Signature>;
+export declare const importSecret: (input: Redacted.Redacted<unknown>, selected: "HS256" | "dir") => Effect.Effect<Readonly<{
+  _tag: "SecretKey";
+  algorithm: "HS256" | "dir";
+  jwk: Redacted.Redacted<{
+    readonly kid?: string;
+    readonly alg?: string;
+    readonly use?: "enc" | "sig";
+    readonly key_ops?: readonly string[];
+    readonly kty: "oct";
+    readonly k: string;
+  }>;
+  material: Redacted.Redacted<Uint8Array<ArrayBufferLike>>;
+}>, InvalidKey, never>;
+export declare const exportPublic: (key: PublicKey) => Effect.Effect<{
+  readonly kid?: string;
+  readonly alg?: string;
+  readonly use?: "enc" | "sig";
+  readonly key_ops?: readonly string[];
+  readonly kty: "RSA";
+  readonly n: string;
+  readonly e: string;
+  readonly d?: never;
+  readonly k?: never;
+} | {
+  readonly kid?: string;
+  readonly alg?: string;
+  readonly use?: "enc" | "sig";
+  readonly key_ops?: readonly string[];
+  readonly kty: "EC";
+  readonly crv: "P-256";
+  readonly x: string;
+  readonly y: string;
+  readonly d?: never;
+  readonly k?: never;
+} | {
+  readonly kid?: string;
+  readonly alg?: string;
+  readonly use?: "enc" | "sig";
+  readonly key_ops?: readonly string[];
+  readonly kty: "OKP";
+  readonly crv: "Ed25519";
+  readonly x: string;
+  readonly d?: never;
+  readonly k?: never;
+}, InvalidKey, never>;
+export declare const exportPrivate: (key: PrivateKey | SecretKey) => Effect.Effect<Redacted.Redacted<{
+  readonly kid?: string;
+  readonly alg?: string;
+  readonly use?: "enc" | "sig";
+  readonly key_ops?: readonly string[];
+  readonly kty: "RSA";
+  readonly n: string;
+  readonly e: string;
+  readonly d: string;
+  readonly p: string;
+  readonly q: string;
+  readonly dp: string;
+  readonly dq: string;
+  readonly qi: string;
+  readonly oth?: never;
+} | {
+  readonly kid?: string;
+  readonly alg?: string;
+  readonly use?: "enc" | "sig";
+  readonly key_ops?: readonly string[];
+  readonly kty: "EC";
+  readonly crv: "P-256";
+  readonly x: string;
+  readonly y: string;
+  readonly d: string;
+} | {
+  readonly kid?: string;
+  readonly alg?: string;
+  readonly use?: "enc" | "sig";
+  readonly key_ops?: readonly string[];
+  readonly kty: "OKP";
+  readonly crv: "Ed25519";
+  readonly x: string;
+  readonly d: string;
+} | {
+  readonly kid?: string;
+  readonly alg?: string;
+  readonly use?: "enc" | "sig";
+  readonly key_ops?: readonly string[];
+  readonly kty: "oct";
+  readonly k: string;
+}>, InvalidKey, never>;
+//#endregion
+//# sourceMappingURL=Jwk.d.mts.map