@yielded/jose 0.1.0-beta.19

package/dist/Jws.mjs

@@ -0,0 +1,108 @@
+import { AlgorithmNotAllowed, InvalidKey, InvalidToken, SignatureVerificationFailed } from "./Errors.mjs";
+import { algorithms } from "./internal/algorithms.mjs";
+import { JsonObject, decode, json, parse, reveal, split, stringify, utf8 } from "./internal/encoding.mjs";
+import { Algorithm } from "./Jwk.mjs";
+import { Jwks } from "./Jwks.mjs";
+import { check } from "./internal/keyPolicy.mjs";
+import { Effect, Redacted, Schema } from "effect";
+import { Signature } from "@yielded/crypto/Signature";
+import { Base64Url } from "effect/encoding";
+import { Hmac } from "@yielded/crypto/Hmac";
+//#region src/Jws.ts
+const Header = Schema.Struct({
+	alg: Algorithm,
+	kid: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(256))),
+	typ: Schema.optionalKey(Schema.NonEmptyString),
+	cty: Schema.optionalKey(Schema.NonEmptyString)
+});
+const VerifyOptions = Schema.Struct({ algorithms: Schema.Array(Algorithm).check(Schema.isMinLength(1)) });
+const readHeader = Effect.fnUntraced(function* (input) {
+	const raw = yield* parse(JsonObject, input, "header");
+	if (raw.crit !== void 0 || raw.b64 !== void 0) return yield* InvalidToken.make({ reason: "header" });
+	return yield* parse(Header, raw, "header");
+});
+const parseCompact = Effect.fnUntraced(function* (token, options) {
+	const policy = yield* parse(VerifyOptions, options, "parameters");
+	const [protectedPart, payloadPart, signaturePart] = yield* split(token, 3);
+	if (protectedPart.length > 4096) return yield* InvalidToken.make({ reason: "header" });
+	const protectedHeader = yield* readHeader(yield* json(yield* decode(protectedPart), "header"));
+	if (!policy.algorithms.includes(protectedHeader.alg)) return yield* AlgorithmNotAllowed.make({});
+	return {
+		protectedHeader,
+		payload: yield* decode(payloadPart),
+		signature: yield* decode(signaturePart),
+		signingInput: utf8(`${protectedPart}.${payloadPart}`)
+	};
+});
+const verifyAsymmetric = Effect.fnUntraced(function* (parsed, key) {
+	const algorithm = parsed.protectedHeader.alg;
+	if (algorithm === "HS256" || key.algorithm !== algorithm) return yield* InvalidKey.make({});
+	yield* check(key.jwk, algorithm, "verify");
+	if (!(yield* (yield* Signature).verify({
+		algorithm: algorithms[algorithm],
+		publicKey: key.material,
+		data: parsed.signingInput,
+		signature: parsed.signature
+	}))) return yield* SignatureVerificationFailed.make({});
+	return {
+		protectedHeader: parsed.protectedHeader,
+		payload: Redacted.make(parsed.payload)
+	};
+});
+const sign = Effect.fnUntraced(function* (payload, key, input) {
+	const header = yield* readHeader(input);
+	if (key.algorithm !== header.alg) return yield* InvalidKey.make({});
+	yield* check(yield* reveal(key.jwk), header.alg, "sign");
+	const data = yield* parse(Schema.Uint8Array.check(Schema.isMaxLength(45e3)), yield* reveal(payload), "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 signingInput = `${protectedPart}.${Base64Url.encode(data)}`;
+	let signature;
+	if (key._tag === "SecretKey") {
+		if (header.alg !== "HS256") return yield* InvalidKey.make({});
+		signature = yield* (yield* Hmac).sign({
+			algorithm: "SHA-256",
+			key: key.material,
+			data: utf8(signingInput)
+		});
+	} else {
+		if (header.alg === "HS256") return yield* InvalidKey.make({});
+		signature = yield* (yield* Signature).sign({
+			algorithm: algorithms[header.alg],
+			privateKey: key.material,
+			data: utf8(signingInput)
+		});
+	}
+	return Redacted.make(`${signingInput}.${Base64Url.encode(signature)}`);
+});
+const verify = Effect.fnUntraced(function* (token, key, options) {
+	const parsed = yield* parseCompact(token, options);
+	if (key._tag !== "SecretKey") return yield* verifyAsymmetric(parsed, key);
+	const algorithm = parsed.protectedHeader.alg;
+	if (key.algorithm !== algorithm) return yield* InvalidKey.make({});
+	yield* check(yield* reveal(key.jwk), algorithm, "verify");
+	if (algorithm !== "HS256") return yield* InvalidKey.make({});
+	if (!(yield* (yield* Hmac).verify({
+		algorithm: "SHA-256",
+		key: key.material,
+		data: parsed.signingInput,
+		tag: parsed.signature
+	}))) return yield* SignatureVerificationFailed.make({});
+	return {
+		protectedHeader: parsed.protectedHeader,
+		payload: Redacted.make(parsed.payload)
+	};
+});
+const verifyWithKeySet = Effect.fnUntraced(function* (token, options) {
+	const parsed = yield* parseCompact(token, options);
+	if (parsed.protectedHeader.alg === "HS256") return yield* InvalidKey.make({});
+	const key = yield* (yield* Jwks).resolve({
+		algorithm: parsed.protectedHeader.alg,
+		...parsed.protectedHeader.kid === void 0 ? {} : { kid: parsed.protectedHeader.kid }
+	});
+	return yield* verifyAsymmetric(parsed, key);
+});
+//#endregion
+export { Header, VerifyOptions, sign, verify, verifyWithKeySet };
+
+//# sourceMappingURL=Jws.mjs.map

package/dist/Jws.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Jws.mjs","names":["KeyPolicy.check"],"sources":["../src/Jws.ts"],"sourcesContent":["import { Hmac } from \"@yielded/crypto/Hmac\";\nimport { Signature } from \"@yielded/crypto/Signature\";\nimport { Effect, Redacted, Schema } from \"effect\";\nimport { Base64Url } from \"effect/encoding\";\n\nimport {\n  AlgorithmNotAllowed,\n  InvalidKey,\n  InvalidToken,\n  SignatureVerificationFailed,\n} from \"./Errors\";\nimport { algorithms } from \"./internal/algorithms\";\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 {\n  Algorithm,\n  type SigningKey,\n  type VerificationKey,\n  type PublicKey,\n  type PrivateJwk,\n  type SecretJwk,\n} from \"./Jwk\";\nimport { Jwks } from \"./Jwks\";\n\nexport const Header = Schema.Struct({\n  alg: Algorithm,\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;\n\nexport const VerifyOptions = Schema.Struct({\n  algorithms: Schema.Array(Algorithm).check(Schema.isMinLength(1)),\n});\n\nexport type VerifyOptions = typeof VerifyOptions.Type;\n\nexport interface Verified {\n  readonly protectedHeader: Header;\n  readonly payload: Redacted.Redacted<Uint8Array>;\n}\n\nexport type Requirements = Hmac | Signature;\n\nconst readHeader = Effect.fnUntraced(function* (input: unknown) {\n  const raw = yield* parse(JsonObject, input, \"header\");\n\n  // No extension handlers are installed. These options change authenticated\n  // processing and may never be silently stripped by the structural schema.\n  if (raw.crit !== undefined || raw.b64 !== undefined)\n    return yield* InvalidToken.make({ reason: \"header\" });\n\n  return yield* parse(Header, raw, \"header\");\n});\n\nconst parseCompact = Effect.fnUntraced(function* (\n  token: Redacted.Redacted<string>,\n  options: VerifyOptions,\n) {\n  const policy = yield* parse(VerifyOptions, options, \"parameters\");\n  const [protectedPart, payloadPart, signaturePart] = yield* split(token, 3);\n\n  if (protectedPart.length > 4096) return yield* InvalidToken.make({ reason: \"header\" });\n  const protectedHeader = yield* readHeader(yield* json(yield* decode(protectedPart), \"header\"));\n\n  if (!policy.algorithms.includes(protectedHeader.alg)) return yield* AlgorithmNotAllowed.make({});\n  const payload = yield* decode(payloadPart);\n  const signature = yield* decode(signaturePart);\n\n  return {\n    protectedHeader,\n    payload,\n    signature,\n    signingInput: utf8(`${protectedPart}.${payloadPart}`),\n  };\n});\n\nconst verifyAsymmetric = Effect.fnUntraced(function* (\n  parsed: Effect.Success<ReturnType<typeof parseCompact>>,\n  key: PublicKey,\n) {\n  const algorithm = parsed.protectedHeader.alg;\n\n  if (algorithm === \"HS256\" || key.algorithm !== algorithm) return yield* InvalidKey.make({});\n  yield* KeyPolicy.check(key.jwk, algorithm, \"verify\");\n  const signatures = yield* Signature;\n\n  const valid = yield* signatures.verify({\n    algorithm: algorithms[algorithm],\n    publicKey: key.material,\n    data: parsed.signingInput,\n    signature: parsed.signature,\n  });\n\n  if (!valid) return yield* SignatureVerificationFailed.make({});\n\n  return {\n    protectedHeader: parsed.protectedHeader,\n    payload: Redacted.make(parsed.payload),\n  } satisfies Verified;\n});\n\nexport const sign = Effect.fnUntraced(function* (\n  payload: Redacted.Redacted<Uint8Array>,\n  key: SigningKey,\n  input: Header,\n) {\n  const header = yield* readHeader(input);\n\n  if (key.algorithm !== header.alg) return yield* InvalidKey.make({});\n  yield* KeyPolicy.check(yield* reveal<PrivateJwk | SecretJwk>(key.jwk), header.alg, \"sign\");\n\n  const data = yield* parse(\n    Schema.Uint8Array.check(Schema.isMaxLength(45000)),\n    yield* reveal(payload),\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 signingInput = `${protectedPart}.${Base64Url.encode(data)}`;\n  let signature: Uint8Array;\n\n  if (key._tag === \"SecretKey\") {\n    if (header.alg !== \"HS256\") return yield* InvalidKey.make({});\n    const hmac = yield* Hmac;\n\n    signature = yield* hmac.sign({\n      algorithm: \"SHA-256\",\n      key: key.material,\n      data: utf8(signingInput),\n    });\n  } else {\n    if (header.alg === \"HS256\") return yield* InvalidKey.make({});\n    const signatures = yield* Signature;\n\n    signature = yield* signatures.sign({\n      algorithm: algorithms[header.alg],\n      privateKey: key.material,\n      data: utf8(signingInput),\n    });\n  }\n\n  return Redacted.make(`${signingInput}.${Base64Url.encode(signature)}`);\n});\n\nexport const verify = Effect.fnUntraced(function* (\n  token: Redacted.Redacted<string>,\n  key: VerificationKey,\n  options: VerifyOptions,\n) {\n  const parsed = yield* parseCompact(token, options);\n\n  if (key._tag !== \"SecretKey\") return yield* verifyAsymmetric(parsed, key);\n  const algorithm = parsed.protectedHeader.alg;\n\n  if (key.algorithm !== algorithm) return yield* InvalidKey.make({});\n  yield* KeyPolicy.check(yield* reveal(key.jwk), algorithm, \"verify\");\n  if (algorithm !== \"HS256\") return yield* InvalidKey.make({});\n  const hmac = yield* Hmac;\n\n  const valid = yield* hmac.verify({\n    algorithm: \"SHA-256\",\n    key: key.material,\n    data: parsed.signingInput,\n    tag: parsed.signature,\n  });\n\n  if (!valid) return yield* SignatureVerificationFailed.make({});\n\n  return {\n    protectedHeader: parsed.protectedHeader,\n    payload: Redacted.make(parsed.payload),\n  } satisfies Verified;\n});\n\nexport const verifyWithKeySet = Effect.fnUntraced(function* (\n  token: Redacted.Redacted<string>,\n  options: VerifyOptions,\n) {\n  const parsed = yield* parseCompact(token, options);\n\n  if (parsed.protectedHeader.alg === \"HS256\") return yield* InvalidKey.make({});\n  const keys = yield* Jwks;\n\n  const key = yield* keys.resolve({\n    algorithm: parsed.protectedHeader.alg,\n    ...(parsed.protectedHeader.kid === undefined ? {} : { kid: parsed.protectedHeader.kid }),\n  });\n\n  return yield* verifyAsymmetric(parsed, key);\n});\n"],"mappings":"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"}

package/dist/Jwt.d.mts

@@ -0,0 +1,69 @@
+import { ClaimValidationFailed, InvalidToken, VerifyError } from "./Errors.mjs";
+import { SigningKey, VerificationKey } from "./Jwk.mjs";
+import { Jwks } from "./Jwks.mjs";
+import { Header, Requirements } from "./Jws.mjs";
+import { Effect, Redacted, Schema } from "effect";
+import { Signature } from "@yielded/crypto/Signature";
+//#region src/Jwt.d.ts
+export declare const RegisteredClaims: Schema.Struct<{
+  readonly iss: Schema.optionalKey<Schema.String>;
+  readonly sub: Schema.optionalKey<Schema.String>;
+  readonly aud: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+  readonly exp: Schema.optionalKey<Schema.Finite>;
+  readonly nbf: Schema.optionalKey<Schema.Finite>;
+  readonly iat: Schema.optionalKey<Schema.Finite>;
+  readonly jti: Schema.optionalKey<Schema.String>;
+}>;
+export type RegisteredClaims = typeof RegisteredClaims.Type;
+export declare const VerifyOptions: Schema.Struct<{
+  readonly algorithms: Schema.$Array<Schema.Literals<readonly ["HS256", "RS256", "PS256", "ES256", "EdDSA"]>>;
+  readonly issuer: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+  readonly audience: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>;
+  readonly subject: Schema.optionalKey<Schema.String>;
+  readonly typ: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly clockTolerance: Schema.optionalKey<Schema.Finite>;
+  readonly maxTokenAge: Schema.optionalKey<Schema.Finite>;
+  readonly requiredClaims: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["iss", "sub", "aud", "exp", "nbf", "iat", "jti"]>>>;
+}>;
+export type VerifyOptions = typeof VerifyOptions.Type;
+export interface Verified<A> {
+  readonly claims: A;
+  readonly registeredClaims: RegisteredClaims;
+  readonly protectedHeader: Header;
+}
+export type JwtError = VerifyError | ClaimValidationFailed | Schema.SchemaError;
+export declare const sign: <S extends Schema.Constraint>(schema: S, claims: S["Type"], key: SigningKey, header: {
+  readonly alg: "ES256" | "EdDSA" | "HS256" | "PS256" | "RS256";
+  readonly kid?: string;
+  readonly typ?: string;
+  readonly cty?: string;
+}) => Effect.Effect<Redacted.Redacted<string>, JwtError, S["EncodingServices"] | Requirements>;
+export declare const verify: <S extends Schema.Constraint>(schema: S, token: Redacted.Redacted<string>, key: VerificationKey, options: {
+  readonly algorithms: readonly ("ES256" | "EdDSA" | "HS256" | "PS256" | "RS256")[];
+  readonly issuer?: string | readonly string[];
+  readonly audience?: string | readonly string[];
+  readonly subject?: string;
+  readonly typ?: string;
+  readonly clockTolerance?: number;
+  readonly maxTokenAge?: number;
+  readonly requiredClaims?: readonly ("aud" | "exp" | "iat" | "iss" | "jti" | "nbf" | "sub")[];
+}) => Effect.Effect<Verified<S["Type"]>, JwtError, S["DecodingServices"] | Requirements>;
+export declare const verifyWithKeySet: <S extends Schema.Constraint>(schema: S, token: Redacted.Redacted<string>, options: {
+  readonly algorithms: readonly ("ES256" | "EdDSA" | "HS256" | "PS256" | "RS256")[];
+  readonly issuer?: string | readonly string[];
+  readonly audience?: string | readonly string[];
+  readonly subject?: string;
+  readonly typ?: string;
+  readonly clockTolerance?: number;
+  readonly maxTokenAge?: number;
+  readonly requiredClaims?: readonly ("aud" | "exp" | "iat" | "iss" | "jti" | "nbf" | "sub")[];
+}) => Effect.Effect<Verified<S["Type"]>, JwtError, Jwks | Signature | S["DecodingServices"]>;
+/** Parsing only. This result does not establish authenticity or validate claims. */
+export declare const decodeUnverified: (token: Redacted.Redacted<string>) => Effect.Effect<{
+  readonly _tag: "UnverifiedJwt";
+  readonly claims: Redacted.Redacted<{
+    readonly [x: string]: Schema.Json;
+  }>;
+}, InvalidToken, never>;
+//#endregion
+//# sourceMappingURL=Jwt.d.mts.map

package/dist/Jwt.mjs

@@ -0,0 +1,145 @@
+import { ClaimValidationFailed } from "./Errors.mjs";
+import { JsonObject, decode, json, parse, reveal, split, stringify, utf8 } from "./internal/encoding.mjs";
+import { VerifyOptions as VerifyOptions$1, sign as sign$1, verify as verify$1, verifyWithKeySet as verifyWithKeySet$1 } from "./Jws.mjs";
+import { Clock, Effect, Redacted, Schema } from "effect";
+//#region src/Jwt.ts
+const RegisteredClaims = Schema.Struct({
+	iss: Schema.optionalKey(Schema.String),
+	sub: Schema.optionalKey(Schema.String),
+	aud: Schema.optionalKey(Schema.Union([Schema.String, Schema.Array(Schema.String)])),
+	exp: Schema.optionalKey(Schema.Finite),
+	nbf: Schema.optionalKey(Schema.Finite),
+	iat: Schema.optionalKey(Schema.Finite),
+	jti: Schema.optionalKey(Schema.String)
+});
+const expected = Schema.Union([Schema.String, Schema.Array(Schema.String).check(Schema.isMinLength(1))]);
+const seconds = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));
+const VerifyOptions = Schema.Struct({
+	...VerifyOptions$1.fields,
+	issuer: Schema.optionalKey(expected),
+	audience: Schema.optionalKey(expected),
+	subject: Schema.optionalKey(Schema.String),
+	typ: Schema.optionalKey(Schema.NonEmptyString),
+	clockTolerance: Schema.optionalKey(seconds),
+	maxTokenAge: Schema.optionalKey(seconds),
+	requiredClaims: Schema.optionalKey(Schema.Array(Schema.Literals([
+		"iss",
+		"sub",
+		"aud",
+		"exp",
+		"nbf",
+		"iat",
+		"jti"
+	])))
+});
+const checkClaims = Effect.fnUntraced(function* (claims, header, options) {
+	const registered = yield* Schema.decodeUnknownEffect(RegisteredClaims)(claims, { reportInput: false }).pipe(Effect.mapError(() => ClaimValidationFailed.make({
+		claim: "registered",
+		reason: "invalid"
+	})));
+	for (const claim of options.requiredClaims ?? []) if (registered[claim] === void 0) return yield* ClaimValidationFailed.make({
+		claim,
+		reason: "missing"
+	});
+	if (options.issuer !== void 0) {
+		if (registered.iss === void 0) return yield* ClaimValidationFailed.make({
+			claim: "iss",
+			reason: "missing"
+		});
+		if (!(typeof options.issuer === "string" ? [options.issuer] : options.issuer).includes(registered.iss)) return yield* ClaimValidationFailed.make({
+			claim: "iss",
+			reason: "mismatch"
+		});
+	}
+	if (options.subject !== void 0) {
+		if (registered.sub === void 0) return yield* ClaimValidationFailed.make({
+			claim: "sub",
+			reason: "missing"
+		});
+		if (options.subject !== registered.sub) return yield* ClaimValidationFailed.make({
+			claim: "sub",
+			reason: "mismatch"
+		});
+	}
+	if (options.audience !== void 0) {
+		if (registered.aud === void 0) return yield* ClaimValidationFailed.make({
+			claim: "aud",
+			reason: "missing"
+		});
+		const expected = typeof options.audience === "string" ? [options.audience] : options.audience;
+		const actual = typeof registered.aud === "string" ? [registered.aud] : registered.aud;
+		if (!expected.some((audience) => actual.includes(audience))) return yield* ClaimValidationFailed.make({
+			claim: "aud",
+			reason: "mismatch"
+		});
+	}
+	const normalizedType = (value) => {
+		const type = value.toLowerCase();
+		return type.includes("/") ? type : `application/${type}`;
+	};
+	if (options.typ !== void 0 && (header.typ === void 0 || normalizedType(header.typ) !== normalizedType(options.typ))) return yield* ClaimValidationFailed.make({
+		claim: "typ",
+		reason: "mismatch"
+	});
+	const now = Math.floor((yield* Clock.currentTimeMillis) / 1e3);
+	const tolerance = options.clockTolerance ?? 0;
+	if (registered.exp !== void 0 && registered.exp <= now - tolerance) return yield* ClaimValidationFailed.make({
+		claim: "exp",
+		reason: "expired"
+	});
+	if (registered.nbf !== void 0 && registered.nbf > now + tolerance) return yield* ClaimValidationFailed.make({
+		claim: "nbf",
+		reason: "notYetValid"
+	});
+	if (options.maxTokenAge !== void 0) {
+		if (registered.iat === void 0) return yield* ClaimValidationFailed.make({
+			claim: "iat",
+			reason: "missing"
+		});
+		if (registered.iat > now + tolerance) return yield* ClaimValidationFailed.make({
+			claim: "iat",
+			reason: "future"
+		});
+		if (now - registered.iat - tolerance > options.maxTokenAge) return yield* ClaimValidationFailed.make({
+			claim: "iat",
+			reason: "tooOld"
+		});
+	}
+	return registered;
+});
+const decodeClaims = Effect.fnUntraced(function* (schema, verified, options) {
+	const wire = yield* json(yield* reveal(verified.payload), "payload");
+	const registeredClaims = yield* checkClaims(wire, verified.protectedHeader, options);
+	return {
+		claims: yield* Schema.decodeUnknownEffect(schema)(wire, { reportInput: false }),
+		registeredClaims,
+		protectedHeader: verified.protectedHeader
+	};
+});
+const sign = Effect.fnUntraced(function* (schema, claims, key, header) {
+	const encoded = yield* Schema.encodeEffect(schema)(claims, { reportInput: false });
+	const wire = yield* Schema.decodeUnknownEffect(JsonObject)(encoded, { reportInput: false });
+	yield* Schema.decodeUnknownEffect(RegisteredClaims)(wire, { reportInput: false });
+	return yield* sign$1(Redacted.make(utf8(yield* stringify(wire))), key, header);
+});
+const verify = Effect.fnUntraced(function* (schema, token, key, options) {
+	const policy = yield* parse(VerifyOptions, options, "parameters");
+	return yield* decodeClaims(schema, yield* verify$1(token, key, policy), policy);
+});
+const verifyWithKeySet = Effect.fnUntraced(function* (schema, token, options) {
+	const policy = yield* parse(VerifyOptions, options, "parameters");
+	return yield* decodeClaims(schema, yield* verifyWithKeySet$1(token, policy), policy);
+});
+/** Parsing only. This result does not establish authenticity or validate claims. */
+const decodeUnverified = Effect.fnUntraced(function* (token) {
+	const [, payload] = yield* split(token, 3);
+	const claims = yield* json(yield* decode(payload), "payload");
+	return {
+		_tag: "UnverifiedJwt",
+		claims: Redacted.make(claims)
+	};
+});
+//#endregion
+export { RegisteredClaims, VerifyOptions, decodeUnverified, sign, verify, verifyWithKeySet };
+
+//# sourceMappingURL=Jwt.mjs.map

package/dist/Jwt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Jwt.mjs","names":["JwsVerifyOptions","Jws.sign","Jws.verify","Jws.verifyWithKeySet"],"sources":["../src/Jwt.ts"],"sourcesContent":["import type { Signature } from \"@yielded/crypto/Signature\";\nimport { Clock, Effect, Redacted, Schema } from \"effect\";\n\nimport { ClaimValidationFailed, type VerifyError } from \"./Errors\";\nimport {\n  decode,\n  json,\n  JsonObject,\n  parse,\n  reveal,\n  split,\n  stringify,\n  utf8,\n} from \"./internal/encoding\";\nimport type { SigningKey, VerificationKey } from \"./Jwk\";\nimport type { Jwks } from \"./Jwks\";\nimport { type Header, type Requirements, VerifyOptions as JwsVerifyOptions } from \"./Jws\";\nimport * as Jws from \"./Jws\";\n\nexport const RegisteredClaims = Schema.Struct({\n  iss: Schema.optionalKey(Schema.String),\n  sub: Schema.optionalKey(Schema.String),\n  aud: Schema.optionalKey(Schema.Union([Schema.String, Schema.Array(Schema.String)])),\n  exp: Schema.optionalKey(Schema.Finite),\n  nbf: Schema.optionalKey(Schema.Finite),\n  iat: Schema.optionalKey(Schema.Finite),\n  jti: Schema.optionalKey(Schema.String),\n});\n\nexport type RegisteredClaims = typeof RegisteredClaims.Type;\n\nconst expected = Schema.Union([\n  Schema.String,\n  Schema.Array(Schema.String).check(Schema.isMinLength(1)),\n]);\n\nconst seconds = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));\n\nexport const VerifyOptions = Schema.Struct({\n  ...JwsVerifyOptions.fields,\n  issuer: Schema.optionalKey(expected),\n  audience: Schema.optionalKey(expected),\n  subject: Schema.optionalKey(Schema.String),\n  typ: Schema.optionalKey(Schema.NonEmptyString),\n  clockTolerance: Schema.optionalKey(seconds),\n  maxTokenAge: Schema.optionalKey(seconds),\n  requiredClaims: Schema.optionalKey(\n    Schema.Array(Schema.Literals([\"iss\", \"sub\", \"aud\", \"exp\", \"nbf\", \"iat\", \"jti\"])),\n  ),\n});\n\nexport type VerifyOptions = typeof VerifyOptions.Type;\n\nexport interface Verified<A> {\n  readonly claims: A;\n  readonly registeredClaims: RegisteredClaims;\n  readonly protectedHeader: Header;\n}\n\nexport type JwtError = VerifyError | ClaimValidationFailed | Schema.SchemaError;\n\nconst checkClaims = Effect.fnUntraced(function* (\n  claims: Readonly<Record<string, Schema.Json>>,\n  header: Header,\n  options: VerifyOptions,\n) {\n  const registered = yield* Schema.decodeUnknownEffect(RegisteredClaims)(claims, {\n    reportInput: false,\n  }).pipe(\n    Effect.mapError(() => ClaimValidationFailed.make({ claim: \"registered\", reason: \"invalid\" })),\n  );\n\n  for (const claim of options.requiredClaims ?? []) {\n    if (registered[claim] === undefined)\n      return yield* ClaimValidationFailed.make({ claim, reason: \"missing\" });\n  }\n  if (options.issuer !== undefined) {\n    if (registered.iss === undefined)\n      return yield* ClaimValidationFailed.make({ claim: \"iss\", reason: \"missing\" });\n    const expected = typeof options.issuer === \"string\" ? [options.issuer] : options.issuer;\n\n    if (!expected.includes(registered.iss))\n      return yield* ClaimValidationFailed.make({ claim: \"iss\", reason: \"mismatch\" });\n  }\n  if (options.subject !== undefined) {\n    if (registered.sub === undefined)\n      return yield* ClaimValidationFailed.make({ claim: \"sub\", reason: \"missing\" });\n    if (options.subject !== registered.sub)\n      return yield* ClaimValidationFailed.make({ claim: \"sub\", reason: \"mismatch\" });\n  }\n  if (options.audience !== undefined) {\n    if (registered.aud === undefined)\n      return yield* ClaimValidationFailed.make({ claim: \"aud\", reason: \"missing\" });\n    const expected = typeof options.audience === \"string\" ? [options.audience] : options.audience;\n    const actual = typeof registered.aud === \"string\" ? [registered.aud] : registered.aud;\n\n    if (!expected.some((audience) => actual.includes(audience)))\n      return yield* ClaimValidationFailed.make({ claim: \"aud\", reason: \"mismatch\" });\n  }\n\n  const normalizedType = (value: string) => {\n    const type = value.toLowerCase();\n\n    return type.includes(\"/\") ? type : `application/${type}`;\n  };\n\n  if (\n    options.typ !== undefined &&\n    (header.typ === undefined || normalizedType(header.typ) !== normalizedType(options.typ))\n  )\n    return yield* ClaimValidationFailed.make({ claim: \"typ\", reason: \"mismatch\" });\n  const now = Math.floor((yield* Clock.currentTimeMillis) / 1000);\n  const tolerance = options.clockTolerance ?? 0;\n\n  if (registered.exp !== undefined && registered.exp <= now - tolerance)\n    return yield* ClaimValidationFailed.make({ claim: \"exp\", reason: \"expired\" });\n  if (registered.nbf !== undefined && registered.nbf > now + tolerance)\n    return yield* ClaimValidationFailed.make({ claim: \"nbf\", reason: \"notYetValid\" });\n  if (options.maxTokenAge !== undefined) {\n    if (registered.iat === undefined)\n      return yield* ClaimValidationFailed.make({ claim: \"iat\", reason: \"missing\" });\n    if (registered.iat > now + tolerance)\n      return yield* ClaimValidationFailed.make({ claim: \"iat\", reason: \"future\" });\n    if (now - registered.iat - tolerance > options.maxTokenAge)\n      return yield* ClaimValidationFailed.make({ claim: \"iat\", reason: \"tooOld\" });\n  }\n\n  return registered;\n});\n\nconst decodeClaims = Effect.fnUntraced(function* <S extends Schema.Constraint>(\n  schema: S,\n  verified: Jws.Verified,\n  options: VerifyOptions,\n) {\n  const wire = yield* json(yield* reveal(verified.payload), \"payload\");\n  const registeredClaims = yield* checkClaims(wire, verified.protectedHeader, options);\n  const claims = yield* Schema.decodeUnknownEffect(schema)(wire, { reportInput: false });\n\n  return { claims, registeredClaims, protectedHeader: verified.protectedHeader } satisfies Verified<\n    S[\"Type\"]\n  >;\n});\n\nexport const sign = Effect.fnUntraced(function* <S extends Schema.Constraint>(\n  schema: S,\n  claims: S[\"Type\"],\n  key: SigningKey,\n  header: Header,\n): Effect.fn.Return<Redacted.Redacted<string>, JwtError, Requirements | S[\"EncodingServices\"]> {\n  const encoded = yield* Schema.encodeEffect(schema)(claims, { reportInput: false });\n  const wire = yield* Schema.decodeUnknownEffect(JsonObject)(encoded, { reportInput: false });\n\n  yield* Schema.decodeUnknownEffect(RegisteredClaims)(wire, { reportInput: false });\n\n  return yield* Jws.sign(Redacted.make(utf8(yield* stringify(wire))), key, header);\n});\n\nexport const verify = Effect.fnUntraced(function* <S extends Schema.Constraint>(\n  schema: S,\n  token: Redacted.Redacted<string>,\n  key: VerificationKey,\n  options: VerifyOptions,\n): Effect.fn.Return<Verified<S[\"Type\"]>, JwtError, Requirements | S[\"DecodingServices\"]> {\n  // Capture all policy before asynchronous cryptography or key resolution.\n  const policy = yield* parse(VerifyOptions, options, \"parameters\");\n\n  return yield* decodeClaims(schema, yield* Jws.verify(token, key, policy), policy);\n});\n\nexport const verifyWithKeySet = Effect.fnUntraced(function* <S extends Schema.Constraint>(\n  schema: S,\n  token: Redacted.Redacted<string>,\n  options: VerifyOptions,\n): Effect.fn.Return<Verified<S[\"Type\"]>, JwtError, Signature | Jwks | S[\"DecodingServices\"]> {\n  const policy = yield* parse(VerifyOptions, options, \"parameters\");\n\n  return yield* decodeClaims(schema, yield* Jws.verifyWithKeySet(token, policy), policy);\n});\n\n/** Parsing only. This result does not establish authenticity or validate claims. */\nexport const decodeUnverified = Effect.fnUntraced(function* (token: Redacted.Redacted<string>) {\n  const [, payload] = yield* split(token, 3);\n  const claims = yield* json(yield* decode(payload), \"payload\");\n\n  return { _tag: \"UnverifiedJwt\", claims: Redacted.make(claims) } as const;\n});\n"],"mappings":";;;;;AAmBA,MAAa,mBAAmB,OAAO,OAAO;CAC5C,KAAK,OAAO,YAAY,OAAO,MAAM;CACrC,KAAK,OAAO,YAAY,OAAO,MAAM;CACrC,KAAK,OAAO,YAAY,OAAO,MAAM,CAAC,OAAO,QAAQ,OAAO,MAAM,OAAO,MAAM,CAAC,CAAC,CAAC;CAClF,KAAK,OAAO,YAAY,OAAO,MAAM;CACrC,KAAK,OAAO,YAAY,OAAO,MAAM;CACrC,KAAK,OAAO,YAAY,OAAO,MAAM;CACrC,KAAK,OAAO,YAAY,OAAO,MAAM;AACvC,CAAC;AAID,MAAM,WAAW,OAAO,MAAM,CAC5B,OAAO,QACP,OAAO,MAAM,OAAO,MAAM,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC,CACzD,CAAC;AAED,MAAM,UAAU,OAAO,OAAO,MAAM,OAAO,uBAAuB,CAAC,CAAC;AAEpE,MAAa,gBAAgB,OAAO,OAAO;CACzC,GAAGA,gBAAiB;CACpB,QAAQ,OAAO,YAAY,QAAQ;CACnC,UAAU,OAAO,YAAY,QAAQ;CACrC,SAAS,OAAO,YAAY,OAAO,MAAM;CACzC,KAAK,OAAO,YAAY,OAAO,cAAc;CAC7C,gBAAgB,OAAO,YAAY,OAAO;CAC1C,aAAa,OAAO,YAAY,OAAO;CACvC,gBAAgB,OAAO,YACrB,OAAO,MAAM,OAAO,SAAS;EAAC;EAAO;EAAO;EAAO;EAAO;EAAO;EAAO;CAAK,CAAC,CAAC,CACjF;AACF,CAAC;AAYD,MAAM,cAAc,OAAO,WAAW,WACpC,QACA,QACA,SACA;CACA,MAAM,aAAa,OAAO,OAAO,oBAAoB,gBAAgB,CAAC,CAAC,QAAQ,EAC7E,aAAa,MACf,CAAC,CAAC,CAAC,KACD,OAAO,eAAe,sBAAsB,KAAK;EAAE,OAAO;EAAc,QAAQ;CAAU,CAAC,CAAC,CAC9F;CAEA,KAAK,MAAM,SAAS,QAAQ,kBAAkB,CAAC,GAC7C,IAAI,WAAW,WAAW,KAAA,GACxB,OAAO,OAAO,sBAAsB,KAAK;EAAE;EAAO,QAAQ;CAAU,CAAC;CAEzE,IAAI,QAAQ,WAAW,KAAA,GAAW;EAChC,IAAI,WAAW,QAAQ,KAAA,GACrB,OAAO,OAAO,sBAAsB,KAAK;GAAE,OAAO;GAAO,QAAQ;EAAU,CAAC;EAG9E,IAAI,EAFa,OAAO,QAAQ,WAAW,WAAW,CAAC,QAAQ,MAAM,IAAI,QAAQ,OAAA,CAEnE,SAAS,WAAW,GAAG,GACnC,OAAO,OAAO,sBAAsB,KAAK;GAAE,OAAO;GAAO,QAAQ;EAAW,CAAC;CACjF;CACA,IAAI,QAAQ,YAAY,KAAA,GAAW;EACjC,IAAI,WAAW,QAAQ,KAAA,GACrB,OAAO,OAAO,sBAAsB,KAAK;GAAE,OAAO;GAAO,QAAQ;EAAU,CAAC;EAC9E,IAAI,QAAQ,YAAY,WAAW,KACjC,OAAO,OAAO,sBAAsB,KAAK;GAAE,OAAO;GAAO,QAAQ;EAAW,CAAC;CACjF;CACA,IAAI,QAAQ,aAAa,KAAA,GAAW;EAClC,IAAI,WAAW,QAAQ,KAAA,GACrB,OAAO,OAAO,sBAAsB,KAAK;GAAE,OAAO;GAAO,QAAQ;EAAU,CAAC;EAC9E,MAAM,WAAW,OAAO,QAAQ,aAAa,WAAW,CAAC,QAAQ,QAAQ,IAAI,QAAQ;EACrF,MAAM,SAAS,OAAO,WAAW,QAAQ,WAAW,CAAC,WAAW,GAAG,IAAI,WAAW;EAElF,IAAI,CAAC,SAAS,MAAM,aAAa,OAAO,SAAS,QAAQ,CAAC,GACxD,OAAO,OAAO,sBAAsB,KAAK;GAAE,OAAO;GAAO,QAAQ;EAAW,CAAC;CACjF;CAEA,MAAM,kBAAkB,UAAkB;EACxC,MAAM,OAAO,MAAM,YAAY;EAE/B,OAAO,KAAK,SAAS,GAAG,IAAI,OAAO,eAAe;CACpD;CAEA,IACE,QAAQ,QAAQ,KAAA,MACf,OAAO,QAAQ,KAAA,KAAa,eAAe,OAAO,GAAG,MAAM,eAAe,QAAQ,GAAG,IAEtF,OAAO,OAAO,sBAAsB,KAAK;EAAE,OAAO;EAAO,QAAQ;CAAW,CAAC;CAC/E,MAAM,MAAM,KAAK,OAAO,OAAO,MAAM,qBAAqB,GAAI;CAC9D,MAAM,YAAY,QAAQ,kBAAkB;CAE5C,IAAI,WAAW,QAAQ,KAAA,KAAa,WAAW,OAAO,MAAM,WAC1D,OAAO,OAAO,sBAAsB,KAAK;EAAE,OAAO;EAAO,QAAQ;CAAU,CAAC;CAC9E,IAAI,WAAW,QAAQ,KAAA,KAAa,WAAW,MAAM,MAAM,WACzD,OAAO,OAAO,sBAAsB,KAAK;EAAE,OAAO;EAAO,QAAQ;CAAc,CAAC;CAClF,IAAI,QAAQ,gBAAgB,KAAA,GAAW;EACrC,IAAI,WAAW,QAAQ,KAAA,GACrB,OAAO,OAAO,sBAAsB,KAAK;GAAE,OAAO;GAAO,QAAQ;EAAU,CAAC;EAC9E,IAAI,WAAW,MAAM,MAAM,WACzB,OAAO,OAAO,sBAAsB,KAAK;GAAE,OAAO;GAAO,QAAQ;EAAS,CAAC;EAC7E,IAAI,MAAM,WAAW,MAAM,YAAY,QAAQ,aAC7C,OAAO,OAAO,sBAAsB,KAAK;GAAE,OAAO;GAAO,QAAQ;EAAS,CAAC;CAC/E;CAEA,OAAO;AACT,CAAC;AAED,MAAM,eAAe,OAAO,WAAW,WACrC,QACA,UACA,SACA;CACA,MAAM,OAAO,OAAO,KAAK,OAAO,OAAO,SAAS,OAAO,GAAG,SAAS;CACnE,MAAM,mBAAmB,OAAO,YAAY,MAAM,SAAS,iBAAiB,OAAO;CAGnF,OAAO;EAAE,QAAA,OAFa,OAAO,oBAAoB,MAAM,CAAC,CAAC,MAAM,EAAE,aAAa,MAAM,CAAC;EAEpE;EAAkB,iBAAiB,SAAS;CAAgB;AAG/E,CAAC;AAED,MAAa,OAAO,OAAO,WAAW,WACpC,QACA,QACA,KACA,QAC6F;CAC7F,MAAM,UAAU,OAAO,OAAO,aAAa,MAAM,CAAC,CAAC,QAAQ,EAAE,aAAa,MAAM,CAAC;CACjF,MAAM,OAAO,OAAO,OAAO,oBAAoB,UAAU,CAAC,CAAC,SAAS,EAAE,aAAa,MAAM,CAAC;CAE1F,OAAO,OAAO,oBAAoB,gBAAgB,CAAC,CAAC,MAAM,EAAE,aAAa,MAAM,CAAC;CAEhF,OAAO,OAAOC,OAAS,SAAS,KAAK,KAAK,OAAO,UAAU,IAAI,CAAC,CAAC,GAAG,KAAK,MAAM;AACjF,CAAC;AAED,MAAa,SAAS,OAAO,WAAW,WACtC,QACA,OACA,KACA,SACuF;CAEvF,MAAM,SAAS,OAAO,MAAM,eAAe,SAAS,YAAY;CAEhE,OAAO,OAAO,aAAa,QAAQ,OAAOC,SAAW,OAAO,KAAK,MAAM,GAAG,MAAM;AAClF,CAAC;AAED,MAAa,mBAAmB,OAAO,WAAW,WAChD,QACA,OACA,SAC2F;CAC3F,MAAM,SAAS,OAAO,MAAM,eAAe,SAAS,YAAY;CAEhE,OAAO,OAAO,aAAa,QAAQ,OAAOC,mBAAqB,OAAO,MAAM,GAAG,MAAM;AACvF,CAAC;;AAGD,MAAa,mBAAmB,OAAO,WAAW,WAAW,OAAkC;CAC7F,MAAM,GAAG,WAAW,OAAO,MAAM,OAAO,CAAC;CACzC,MAAM,SAAS,OAAO,KAAK,OAAO,OAAO,OAAO,GAAG,SAAS;CAE5D,OAAO;EAAE,MAAM;EAAiB,QAAQ,SAAS,KAAK,MAAM;CAAE;AAChE,CAAC"}

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+import * as Errors from "./Errors.mjs";
+import * as Jwk from "./Jwk.mjs";
+import * as Jwks from "./Jwks.mjs";
+import * as Jws from "./Jws.mjs";
+import * as Jwt from "./Jwt.mjs";
+import * as Jwe from "./Jwe.mjs";
+export { Errors, Jwe, Jwk, Jwks, Jws, Jwt };

package/dist/index.mjs

@@ -0,0 +1,7 @@
+import * as Errors from "./Errors.mjs";
+import * as Jwk from "./Jwk.mjs";
+import * as Jwks from "./Jwks.mjs";
+import * as Jws from "./Jws.mjs";
+import * as Jwt from "./Jwt.mjs";
+import * as Jwe from "./Jwe.mjs";
+export { Errors, Jwe, Jwk, Jwks, Jws, Jwt };

package/dist/internal/algorithms.mjs

@@ -0,0 +1,11 @@
+//#region src/internal/algorithms.ts
+const algorithms = {
+	ES256: "ECDSA-P256-SHA256",
+	RS256: "RSASSA-PKCS1-v1_5-SHA256",
+	PS256: "RSA-PSS-SHA256",
+	EdDSA: "Ed25519"
+};
+//#endregion
+export { algorithms };
+
+//# sourceMappingURL=algorithms.mjs.map

package/dist/internal/algorithms.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"algorithms.mjs","names":[],"sources":["../../src/internal/algorithms.ts"],"sourcesContent":["import type { Algorithm } from \"@yielded/crypto/Signature\";\n\nimport type { AsymmetricAlgorithm } from \"../Jwk\";\n\nexport const algorithms = {\n  ES256: \"ECDSA-P256-SHA256\",\n  RS256: \"RSASSA-PKCS1-v1_5-SHA256\",\n  PS256: \"RSA-PSS-SHA256\",\n  EdDSA: \"Ed25519\",\n} satisfies Record<AsymmetricAlgorithm, Algorithm>;\n"],"mappings":";AAIA,MAAa,aAAa;CACxB,OAAO;CACP,OAAO;CACP,OAAO;CACP,OAAO;AACT"}

package/dist/internal/encoding.mjs

@@ -0,0 +1,39 @@
+import { InvalidToken } from "../Errors.mjs";
+import { Effect, Redacted, Result, Schema } from "effect";
+import { Base64Url } from "effect/encoding";
+//#region src/internal/encoding.ts
+const JsonObject = Schema.Record(Schema.String, Schema.Json);
+const utf8 = (value) => new TextEncoder().encode(value);
+const Segment = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]*$/), Schema.isMaxLength(65536));
+const Token = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(65536));
+const parse = (schema, input, reason) => Effect.suspend(() => Schema.decodeUnknownEffect(schema)(input, { reportInput: false })).pipe(Effect.mapError(() => InvalidToken.make({ reason })), Effect.catchDefect(() => InvalidToken.make({ reason })));
+const reveal = (value) => Effect.try({
+	try: () => Redacted.value(value),
+	catch: () => InvalidToken.make({ reason: "parameters" })
+});
+const decode = Effect.fnUntraced(function* (value, reason = "serialization") {
+	yield* parse(Segment, value, reason);
+	const bytes = yield* Result.match(Base64Url.decode(value), {
+		onFailure: () => Effect.fail(InvalidToken.make({ reason })),
+		onSuccess: Effect.succeed
+	});
+	if (Base64Url.encode(bytes) !== value) return yield* InvalidToken.make({ reason });
+	return bytes;
+});
+const json = Effect.fnUntraced(function* (bytes, reason) {
+	const value = yield* Effect.try({
+		try: () => new TextDecoder("utf-8", { fatal: true }).decode(bytes),
+		catch: () => InvalidToken.make({ reason })
+	});
+	return yield* parse(Schema.fromJsonString(JsonObject), value, reason);
+});
+const stringify = (value) => Schema.encodeEffect(Schema.fromJsonString(JsonObject))(value, { reportInput: false });
+const split = Effect.fnUntraced(function* (input, count) {
+	const parts = (yield* parse(Token, yield* reveal(input), "serialization")).split(".");
+	if (parts.length !== count) return yield* InvalidToken.make({ reason: "serialization" });
+	return parts;
+});
+//#endregion
+export { JsonObject, decode, json, parse, reveal, split, stringify, utf8 };
+
+//# sourceMappingURL=encoding.mjs.map

package/dist/internal/encoding.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.mjs","names":[],"sources":["../../src/internal/encoding.ts"],"sourcesContent":["import { Effect, Redacted, Result, Schema } from \"effect\";\nimport { Base64Url } from \"effect/encoding\";\n\nimport { InvalidToken } from \"../Errors\";\n\nexport const JsonObject = Schema.Record(Schema.String, Schema.Json);\nexport const utf8 = (value: string) => new TextEncoder().encode(value);\n\nconst Segment = Schema.String.check(\n  Schema.isPattern(/^[A-Za-z0-9_-]*$/),\n  Schema.isMaxLength(65536),\n);\n\nconst Token = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(65536));\n\nexport const parse = <S extends Schema.Constraint>(\n  schema: S,\n  input: unknown,\n  reason: InvalidToken[\"reason\"],\n) =>\n  Effect.suspend(() => Schema.decodeUnknownEffect(schema)(input, { reportInput: false })).pipe(\n    Effect.mapError(() => InvalidToken.make({ reason })),\n    // Arbitrary nested input can still invoke foreign getters during decoding.\n    Effect.catchDefect(() => InvalidToken.make({ reason })),\n  );\n\nexport const reveal = <A>(value: Redacted.Redacted<A>) =>\n  Effect.try({\n    try: () => Redacted.value(value),\n    catch: () => InvalidToken.make({ reason: \"parameters\" }),\n  });\n\nexport const decode = Effect.fnUntraced(function* (\n  value: string,\n  reason: InvalidToken[\"reason\"] = \"serialization\",\n) {\n  yield* parse(Segment, value, reason);\n\n  const bytes = yield* Result.match(Base64Url.decode(value), {\n    onFailure: () => Effect.fail(InvalidToken.make({ reason })),\n    onSuccess: Effect.succeed,\n  });\n\n  // Canonical, unpadded base64url also rejects non-zero unused bits.\n  if (Base64Url.encode(bytes) !== value) return yield* InvalidToken.make({ reason });\n\n  return bytes;\n});\n\nexport const json = Effect.fnUntraced(function* (\n  bytes: Uint8Array,\n  reason: InvalidToken[\"reason\"],\n) {\n  const value = yield* Effect.try({\n    try: () => new TextDecoder(\"utf-8\", { fatal: true }).decode(bytes),\n    catch: () => InvalidToken.make({ reason }),\n  });\n\n  return yield* parse(Schema.fromJsonString(JsonObject), value, reason);\n});\n\nexport const stringify = (value: Readonly<Record<string, Schema.Json>>) =>\n  Schema.encodeEffect(Schema.fromJsonString(JsonObject))(value, { reportInput: false });\n\nexport const split = Effect.fnUntraced(function* (input: Redacted.Redacted<string>, count: number) {\n  const value = yield* parse(Token, yield* reveal(input), \"serialization\");\n  const parts = value.split(\".\");\n\n  if (parts.length !== count) return yield* InvalidToken.make({ reason: \"serialization\" });\n\n  return parts;\n});\n"],"mappings":";;;;AAKA,MAAa,aAAa,OAAO,OAAO,OAAO,QAAQ,OAAO,IAAI;AAClE,MAAa,QAAQ,UAAkB,IAAI,YAAY,CAAC,CAAC,OAAO,KAAK;AAErE,MAAM,UAAU,OAAO,OAAO,MAC5B,OAAO,UAAU,kBAAkB,GACnC,OAAO,YAAY,KAAK,CAC1B;AAEA,MAAM,QAAQ,OAAO,OAAO,MAAM,OAAO,YAAY,CAAC,GAAG,OAAO,YAAY,KAAK,CAAC;AAElF,MAAa,SACX,QACA,OACA,WAEA,OAAO,cAAc,OAAO,oBAAoB,MAAM,CAAC,CAAC,OAAO,EAAE,aAAa,MAAM,CAAC,CAAC,CAAC,CAAC,KACtF,OAAO,eAAe,aAAa,KAAK,EAAE,OAAO,CAAC,CAAC,GAEnD,OAAO,kBAAkB,aAAa,KAAK,EAAE,OAAO,CAAC,CAAC,CACxD;AAEF,MAAa,UAAa,UACxB,OAAO,IAAI;CACT,WAAW,SAAS,MAAM,KAAK;CAC/B,aAAa,aAAa,KAAK,EAAE,QAAQ,aAAa,CAAC;AACzD,CAAC;AAEH,MAAa,SAAS,OAAO,WAAW,WACtC,OACA,SAAiC,iBACjC;CACA,OAAO,MAAM,SAAS,OAAO,MAAM;CAEnC,MAAM,QAAQ,OAAO,OAAO,MAAM,UAAU,OAAO,KAAK,GAAG;EACzD,iBAAiB,OAAO,KAAK,aAAa,KAAK,EAAE,OAAO,CAAC,CAAC;EAC1D,WAAW,OAAO;CACpB,CAAC;CAGD,IAAI,UAAU,OAAO,KAAK,MAAM,OAAO,OAAO,OAAO,aAAa,KAAK,EAAE,OAAO,CAAC;CAEjF,OAAO;AACT,CAAC;AAED,MAAa,OAAO,OAAO,WAAW,WACpC,OACA,QACA;CACA,MAAM,QAAQ,OAAO,OAAO,IAAI;EAC9B,WAAW,IAAI,YAAY,SAAS,EAAE,OAAO,KAAK,CAAC,CAAC,CAAC,OAAO,KAAK;EACjE,aAAa,aAAa,KAAK,EAAE,OAAO,CAAC;CAC3C,CAAC;CAED,OAAO,OAAO,MAAM,OAAO,eAAe,UAAU,GAAG,OAAO,MAAM;AACtE,CAAC;AAED,MAAa,aAAa,UACxB,OAAO,aAAa,OAAO,eAAe,UAAU,CAAC,CAAC,CAAC,OAAO,EAAE,aAAa,MAAM,CAAC;AAEtF,MAAa,QAAQ,OAAO,WAAW,WAAW,OAAkC,OAAe;CAEjG,MAAM,SAAQ,OADO,MAAM,OAAO,OAAO,OAAO,KAAK,GAAG,eAAe,EAAA,CACnD,MAAM,GAAG;CAE7B,IAAI,MAAM,WAAW,OAAO,OAAO,OAAO,aAAa,KAAK,EAAE,QAAQ,gBAAgB,CAAC;CAEvF,OAAO;AACT,CAAC"}

package/dist/internal/keyInput.mjs

@@ -0,0 +1,44 @@
+import { InvalidKey } from "../Errors.mjs";
+import { Predicate, Result, Schema } from "effect";
+const ArrayLength = Schema.Int.check(Schema.isBetween({
+	minimum: 0,
+	maximum: 256
+}));
+/** Copy only own fields, evaluating accessors once before Schema validation. */
+const object = (input) => {
+	if (!Predicate.isObject(input)) return input;
+	const descriptors = Object.getOwnPropertyDescriptors(input);
+	const copy = {};
+	Object.setPrototypeOf(copy, null);
+	for (const name of Object.getOwnPropertyNames(descriptors)) {
+		const descriptor = descriptors[name];
+		copy[name] = Object.hasOwn(descriptor, "value") ? descriptor.value : descriptor.get?.call(input);
+	}
+	return copy;
+};
+const array = (input) => Result.gen(function* () {
+	const length = yield* Schema.decodeUnknownResult(ArrayLength)(input.length).pipe(Result.mapError(() => InvalidKey.make({})));
+	return Array.from({ length }, (_, index) => Object.getOwnPropertyDescriptor(input, index)).map((descriptor) => descriptor === void 0 ? void 0 : Object.hasOwn(descriptor, "value") ? descriptor.value : descriptor.get?.call(input));
+});
+const jwk = (input) => Result.gen(function* () {
+	const copy = object(input);
+	if (Predicate.isObject(copy) && Array.isArray(copy.key_ops)) copy.key_ops = yield* array(copy.key_ops);
+	return copy;
+});
+const keySet = (input) => Result.gen(function* () {
+	const copy = object(input);
+	if (Predicate.isObject(copy) && Array.isArray(copy.keys)) {
+		const keys = yield* array(copy.keys);
+		copy.keys = yield* Result.all(keys.map(jwk));
+	}
+	return copy;
+});
+/** Struct decoding creates ordinary objects; detach owned output as well. */
+const detach = (value) => {
+	if (Predicate.isObject(value)) Object.setPrototypeOf(value, null);
+	return value;
+};
+//#endregion
+export { detach, jwk, keySet, object };
+
+//# sourceMappingURL=keyInput.mjs.map

package/dist/internal/keyInput.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyInput.mjs","names":[],"sources":["../../src/internal/keyInput.ts"],"sourcesContent":["import { Predicate, Result, Schema } from \"effect\";\n\nimport { InvalidKey } from \"../Errors\";\n\nexport const maxArrayLength = 256;\n\nconst ArrayLength = Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: maxArrayLength }));\n\n/** Copy only own fields, evaluating accessors once before Schema validation. */\nexport const object = (input: unknown): unknown => {\n  if (!Predicate.isObject(input)) return input;\n  const descriptors = Object.getOwnPropertyDescriptors(input);\n  const copy: Record<string, unknown> = {};\n\n  Object.setPrototypeOf(copy, null);\n  for (const name of Object.getOwnPropertyNames(descriptors)) {\n    const descriptor = descriptors[name];\n\n    copy[name] = Object.hasOwn(descriptor, \"value\")\n      ? descriptor.value\n      : descriptor.get?.call(input);\n  }\n\n  return copy;\n};\n\nconst array = (input: ReadonlyArray<unknown>) =>\n  Result.gen(function* () {\n    const length = yield* Schema.decodeUnknownResult(ArrayLength)(input.length).pipe(\n      Result.mapError(() => InvalidKey.make({})),\n    );\n\n    // Capture bounded own slots before any accessor can mutate the array.\n    const descriptors = Array.from({ length }, (_, index) =>\n      Object.getOwnPropertyDescriptor(input, index),\n    );\n\n    return descriptors.map((descriptor) =>\n      descriptor === undefined\n        ? undefined\n        : Object.hasOwn(descriptor, \"value\")\n          ? descriptor.value\n          : descriptor.get?.call(input),\n    );\n  });\n\nexport const jwk = (input: unknown) =>\n  Result.gen(function* () {\n    const copy = object(input);\n\n    if (Predicate.isObject(copy) && Array.isArray(copy.key_ops))\n      copy.key_ops = yield* array(copy.key_ops);\n\n    return copy;\n  });\n\nexport const keySet = (input: unknown) =>\n  Result.gen(function* () {\n    const copy = object(input);\n\n    if (Predicate.isObject(copy) && Array.isArray(copy.keys)) {\n      const keys = yield* array(copy.keys);\n\n      copy.keys = yield* Result.all(keys.map(jwk));\n    }\n\n    return copy;\n  });\n\n/** Struct decoding creates ordinary objects; detach owned output as well. */\nexport const detach = <A>(value: A): A => {\n  if (Predicate.isObject(value)) Object.setPrototypeOf(value, null);\n\n  return value;\n};\n"],"mappings":";;AAMA,MAAM,cAAc,OAAO,IAAI,MAAM,OAAO,UAAU;CAAE,SAAS;CAAG,SAAA;AAAwB,CAAC,CAAC;;AAG9F,MAAa,UAAU,UAA4B;CACjD,IAAI,CAAC,UAAU,SAAS,KAAK,GAAG,OAAO;CACvC,MAAM,cAAc,OAAO,0BAA0B,KAAK;CAC1D,MAAM,OAAgC,CAAC;CAEvC,OAAO,eAAe,MAAM,IAAI;CAChC,KAAK,MAAM,QAAQ,OAAO,oBAAoB,WAAW,GAAG;EAC1D,MAAM,aAAa,YAAY;EAE/B,KAAK,QAAQ,OAAO,OAAO,YAAY,OAAO,IAC1C,WAAW,QACX,WAAW,KAAK,KAAK,KAAK;CAChC;CAEA,OAAO;AACT;AAEA,MAAM,SAAS,UACb,OAAO,IAAI,aAAa;CACtB,MAAM,SAAS,OAAO,OAAO,oBAAoB,WAAW,CAAC,CAAC,MAAM,MAAM,CAAC,CAAC,KAC1E,OAAO,eAAe,WAAW,KAAK,CAAC,CAAC,CAAC,CAC3C;CAOA,OAJoB,MAAM,KAAK,EAAE,OAAO,IAAI,GAAG,UAC7C,OAAO,yBAAyB,OAAO,KAAK,CAG7B,CAAC,CAAC,KAAK,eACtB,eAAe,KAAA,IACX,KAAA,IACA,OAAO,OAAO,YAAY,OAAO,IAC/B,WAAW,QACX,WAAW,KAAK,KAAK,KAAK,CAClC;AACF,CAAC;AAEH,MAAa,OAAO,UAClB,OAAO,IAAI,aAAa;CACtB,MAAM,OAAO,OAAO,KAAK;CAEzB,IAAI,UAAU,SAAS,IAAI,KAAK,MAAM,QAAQ,KAAK,OAAO,GACxD,KAAK,UAAU,OAAO,MAAM,KAAK,OAAO;CAE1C,OAAO;AACT,CAAC;AAEH,MAAa,UAAU,UACrB,OAAO,IAAI,aAAa;CACtB,MAAM,OAAO,OAAO,KAAK;CAEzB,IAAI,UAAU,SAAS,IAAI,KAAK,MAAM,QAAQ,KAAK,IAAI,GAAG;EACxD,MAAM,OAAO,OAAO,MAAM,KAAK,IAAI;EAEnC,KAAK,OAAO,OAAO,OAAO,IAAI,KAAK,IAAI,GAAG,CAAC;CAC7C;CAEA,OAAO;AACT,CAAC;;AAGH,MAAa,UAAa,UAAgB;CACxC,IAAI,UAAU,SAAS,KAAK,GAAG,OAAO,eAAe,OAAO,IAAI;CAEhE,OAAO;AACT"}

package/dist/internal/keyPolicy.mjs

@@ -0,0 +1,11 @@
+import { InvalidKey } from "../Errors.mjs";
+import { Effect } from "effect";
+//#region src/internal/keyPolicy.ts
+const check = (jwk, algorithm, operation) => {
+	const use = operation === "sign" || operation === "verify" ? "sig" : "enc";
+	return jwk.alg !== void 0 && jwk.alg !== algorithm || jwk.use !== void 0 && jwk.use !== use || jwk.key_ops !== void 0 && !jwk.key_ops.includes(operation) ? Effect.fail(InvalidKey.make({})) : Effect.void;
+};
+//#endregion
+export { check };
+
+//# sourceMappingURL=keyPolicy.mjs.map

package/dist/internal/keyPolicy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyPolicy.mjs","names":[],"sources":["../../src/internal/keyPolicy.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport { InvalidKey } from \"../Errors\";\nimport type { PrivateJwk, PublicJwk, SecretJwk } from \"../Jwk\";\n\nexport const check = (\n  jwk: PublicJwk | PrivateJwk | SecretJwk,\n  algorithm: string,\n  operation: \"sign\" | \"verify\" | \"encrypt\" | \"decrypt\",\n) => {\n  const use = operation === \"sign\" || operation === \"verify\" ? \"sig\" : \"enc\";\n\n  return (jwk.alg !== undefined && jwk.alg !== algorithm) ||\n    (jwk.use !== undefined && jwk.use !== use) ||\n    (jwk.key_ops !== undefined && !jwk.key_ops.includes(operation))\n    ? Effect.fail(InvalidKey.make({}))\n    : Effect.void;\n};\n"],"mappings":";;;AAKA,MAAa,SACX,KACA,WACA,cACG;CACH,MAAM,MAAM,cAAc,UAAU,cAAc,WAAW,QAAQ;CAErE,OAAQ,IAAI,QAAQ,KAAA,KAAa,IAAI,QAAQ,aAC1C,IAAI,QAAQ,KAAA,KAAa,IAAI,QAAQ,OACrC,IAAI,YAAY,KAAA,KAAa,CAAC,IAAI,QAAQ,SAAS,SAAS,IAC3D,OAAO,KAAK,WAAW,KAAK,CAAC,CAAC,CAAC,IAC/B,OAAO;AACb"}

package/package.json

@@ -0,0 +1 @@
+{"name":"@yielded/jose","version":"0.1.0-beta.19","dependencies":{"@yielded/crypto":"0.1.0-beta.19"},"devDependencies":{"@effect/platform-node":"4.0.0","@effect/vitest":"4.0.0","@types/node":"26.1.2","effect":"4.0.0","jose":"6.2.12","typescript":"7.0.2","vite-plus":"0.3.3"},"peerDependencies":{"effect":"^4.0.0"},"exports":{".":{"types":"./dist/index.d.mts","default":"./dist/index.mjs"},"./Errors":{"types":"./dist/Errors.d.mts","default":"./dist/Errors.mjs"},"./Jwk":{"types":"./dist/Jwk.d.mts","default":"./dist/Jwk.mjs"},"./Jwks":{"types":"./dist/Jwks.d.mts","default":"./dist/Jwks.mjs"},"./Jws":{"types":"./dist/Jws.d.mts","default":"./dist/Jws.mjs"},"./Jwt":{"types":"./dist/Jwt.d.mts","default":"./dist/Jwt.mjs"},"./Jwe":{"types":"./dist/Jwe.d.mts","default":"./dist/Jwe.mjs"}},"description":"Schema-typed Effect JOSE with explicit keys, cryptography, and remote JWKS trust.","homepage":"https://yielded.dev/auth/","bugs":{"url":"https://github.com/yielded-dev/auth/issues"},"license":"MIT","repository":{"type":"git","url":"git+https://github.com/yielded-dev/auth.git","directory":"packages/jose"},"files":["dist","src","THIRD_PARTY_NOTICES.md"],"type":"module","sideEffects":[],"publishConfig":{"access":"public"},"scripts":{"build":"vp pack","check":"tsc --noEmit -p tsconfig.json","test":"vp test"}}

package/src/Errors.ts

@@ -0,0 +1,55 @@
+import type { OperationError as CryptoError } from "@yielded/crypto/Errors";
+import { Schema } from "effect";
+
+/** Fixed diagnostics never include a token, claims, key, URL, or native cause. */
+export class InvalidToken extends Schema.TaggedError<InvalidToken>()("JoseInvalidToken", {
+  reason: Schema.Literals(["serialization", "header", "payload", "parameters"]),
+}) {}
+
+export class AlgorithmNotAllowed extends Schema.TaggedError<AlgorithmNotAllowed>()(
+  "JoseAlgorithmNotAllowed",
+  {},
+) {}
+
+export class InvalidKey extends Schema.TaggedError<InvalidKey>()("JoseInvalidKey", {}) {}
+
+export class SignatureVerificationFailed extends Schema.TaggedError<SignatureVerificationFailed>()(
+  "JoseSignatureVerificationFailed",
+  {},
+) {}
+
+export class DecryptionFailed extends Schema.TaggedError<DecryptionFailed>()(
+  "JoseDecryptionFailed",
+  {},
+) {}
+
+export class KeyNotFound extends Schema.TaggedError<KeyNotFound>()("JoseKeyNotFound", {}) {}
+export class AmbiguousKey extends Schema.TaggedError<AmbiguousKey>()("JoseAmbiguousKey", {}) {}
+
+export class JwksUnavailable extends Schema.TaggedError<JwksUnavailable>()("JoseJwksUnavailable", {
+  reason: Schema.Literals(["configuration", "transport", "response", "cooldown", "busy", "closed"]),
+}) {}
+
+export class ClaimValidationFailed extends Schema.TaggedError<ClaimValidationFailed>()(
+  "JoseClaimValidationFailed",
+  {
+    claim: Schema.Literals(["registered", "iss", "sub", "aud", "exp", "nbf", "iat", "jti", "typ"]),
+    reason: Schema.Literals([
+      "invalid",
+      "missing",
+      "mismatch",
+      "expired",
+      "notYetValid",
+      "tooOld",
+      "future",
+    ]),
+  },
+) {}
+
+export type KeyError = InvalidKey | KeyNotFound | AmbiguousKey | JwksUnavailable | CryptoError;
+
+export type VerifyError =
+  | KeyError
+  | InvalidToken
+  | AlgorithmNotAllowed
+  | SignatureVerificationFailed;