@tldraw/editor 3.16.0-canary.cb97f41de62b → 3.16.0-canary.cc5427cdff41

package/src/lib/license/LicenseManager.test.ts

@@ -4,7 +4,7 @@ import { publishDates } from '../../version'
 import { str2ab } from '../utils/licensing'
 import {
 	FLAGS,
-	isEditorUnlicensed,
+	getLicenseState,
 	LicenseManager,
 	PROPERTIES,
 	ValidLicenseKeyResult,
@@ -52,337 +52,421 @@ describe('LicenseManager', () => {
 		window.location = new URL('https://www.example.com')
 	})
 
-	it('Fails if no key provided', async () => {
-		const result = await licenseManager.getLicenseFromKey('')
-		expect(result).toMatchObject({ isLicenseParseable: false, reason: 'no-key-provided' })
-	})
+	describe('Basic license validation', () => {
+		it('Fails if no key provided', async () => {
+			const result = await licenseManager.getLicenseFromKey('')
+			expect(result).toMatchObject({ isLicenseParseable: false, reason: 'no-key-provided' })
+		})
 
-	it('Signals that it is development mode when appropriate', async () => {
-		const schemes = ['http', 'https']
-		for (const scheme of schemes) {
-			// @ts-ignore
-			delete window.location
-			// @ts-ignore
-			window.location = new URL(`${scheme}://localhost:3000`)
+		it('Signals that it is development mode when appropriate', async () => {
+			const schemes = ['http', 'https']
+			for (const scheme of schemes) {
+				// @ts-ignore
+				delete window.location
+				// @ts-ignore
+				window.location = new URL(`${scheme}://localhost:3000`)
+
+				const testEnvLicenseManager = new LicenseManager('', keyPair.publicKey, 'development')
+				const licenseKey = await generateLicenseKey(STANDARD_LICENSE_INFO, keyPair)
+				const result = await testEnvLicenseManager.getLicenseFromKey(licenseKey)
+				expect(result).toMatchObject({
+					isLicenseParseable: true,
+					isDomainValid: false,
+					isDevelopment: true,
+				})
+			}
+		})
+
+		it('Cleanses out valid keys that accidentally have zero-width characters or newlines', async () => {
+			const cleanLicenseKey = await generateLicenseKey(STANDARD_LICENSE_INFO, keyPair)
+			const dirtyLicenseKey = cleanLicenseKey + '\u200B\u200D\uFEFF\n\r'
+			const result = await licenseManager.getLicenseFromKey(dirtyLicenseKey)
+			expect(result.isLicenseParseable).toBe(true)
+		})
+
+		it('Fails if garbage key provided', async () => {
+			const badPublicKeyLicenseManager = new LicenseManager('', 'badpublickey', 'production')
+			const invalidLicenseKey = await generateLicenseKey(STANDARD_LICENSE_INFO, keyPair)
+			const result = await badPublicKeyLicenseManager.getLicenseFromKey(invalidLicenseKey)
+			expect(result).toMatchObject({ isLicenseParseable: false, reason: 'invalid-license-key' })
+		})
+
+		it('Fails if non-JSON parseable message is provided', async () => {
+			const invalidMessage = await generateLicenseKey('asdfsad', keyPair)
+			const result = await licenseManager.getLicenseFromKey(invalidMessage)
+			expect(result).toMatchObject({ isLicenseParseable: false, reason: 'invalid-license-key' })
+		})
 
-			const testEnvLicenseManager = new LicenseManager('', keyPair.publicKey, 'development')
+		it('Succeeds if valid key provided', async () => {
 			const licenseKey = await generateLicenseKey(STANDARD_LICENSE_INFO, keyPair)
-			const result = await testEnvLicenseManager.getLicenseFromKey(licenseKey)
+			const result = await licenseManager.getLicenseFromKey(licenseKey)
 			expect(result).toMatchObject({
 				isLicenseParseable: true,
-				isDomainValid: false,
-				isDevelopment: true,
-			})
-		}
+				license: {
+					id: 'id',
+					hosts: ['www.example.com'],
+					flags: FLAGS.ANNUAL_LICENSE,
+					expiryDate,
+				},
+				isDomainValid: true,
+				isAnnualLicense: true,
+				isAnnualLicenseExpired: false,
+				isPerpetualLicense: false,
+				isPerpetualLicenseExpired: false,
+				isInternalLicense: false,
+				isEvaluationLicense: false,
+				isEvaluationLicenseExpired: false,
+				daysSinceExpiry: 0,
+			} as ValidLicenseKeyResult)
+		})
 	})
 
-	it('Cleanses out valid keys that accidentally have zero-width characters or newlines', async () => {
-		const cleanLicenseKey = await generateLicenseKey(STANDARD_LICENSE_INFO, keyPair)
-		const dirtyLicenseKey = cleanLicenseKey + '\u200B\u200D\uFEFF\n\r'
-		const result = await licenseManager.getLicenseFromKey(dirtyLicenseKey)
-		expect(result.isLicenseParseable).toBe(true)
-	})
+	describe('Domain validation', () => {
+		it('Fails with invalid host', async () => {
+			// @ts-ignore
+			delete window.location
+			// @ts-ignore
+			window.location = new URL('https://www.foo.com')
 
-	it('Fails if garbage key provided', async () => {
-		const badPublicKeyLicenseManager = new LicenseManager('', 'badpublickey', 'production')
-		const invalidLicenseKey = await generateLicenseKey(STANDARD_LICENSE_INFO, keyPair)
-		const result = await badPublicKeyLicenseManager.getLicenseFromKey(invalidLicenseKey)
-		expect(result).toMatchObject({ isLicenseParseable: false, reason: 'invalid-license-key' })
-	})
+			const expiredLicenseKey = await generateLicenseKey(STANDARD_LICENSE_INFO, keyPair)
+			const result = (await licenseManager.getLicenseFromKey(
+				expiredLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isDomainValid).toBe(false)
+		})
 
-	it('Fails if non-JSON parseable message is provided', async () => {
-		const invalidMessage = await generateLicenseKey('asdfsad', keyPair)
-		const result = await licenseManager.getLicenseFromKey(invalidMessage)
-		expect(result).toMatchObject({ isLicenseParseable: false, reason: 'invalid-license-key' })
-	})
+		it('Succeeds if hosts is equal to only "*"', async () => {
+			// @ts-ignore
+			delete window.location
+			// @ts-ignore
+			window.location = new URL('https://www.foo.com')
+
+			const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			permissiveHostsInfo[PROPERTIES.HOSTS] = ['*']
+			const permissiveLicenseKey = await generateLicenseKey(
+				JSON.stringify(permissiveHostsInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				permissiveLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isDomainValid).toBe(true)
+		})
 
-	it('Succeeds if valid key provided', async () => {
-		const licenseKey = await generateLicenseKey(STANDARD_LICENSE_INFO, keyPair)
-		const result = await licenseManager.getLicenseFromKey(licenseKey)
-		expect(result).toMatchObject({
-			isLicenseParseable: true,
-			license: {
-				id: 'id',
-				hosts: ['www.example.com'],
-				flags: FLAGS.ANNUAL_LICENSE,
-				expiryDate,
-			},
-			isDomainValid: true,
-			isAnnualLicense: true,
-			isAnnualLicenseExpired: false,
-			isPerpetualLicense: false,
-			isPerpetualLicenseExpired: false,
-			isInternalLicense: false,
-		} as ValidLicenseKeyResult)
-	})
+		it('Succeeds if has an apex domain specified', async () => {
+			// @ts-ignore
+			delete window.location
+			// @ts-ignore
+			window.location = new URL('https://www.example.com')
+
+			const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			permissiveHostsInfo[PROPERTIES.HOSTS] = ['example.com']
+			const permissiveLicenseKey = await generateLicenseKey(
+				JSON.stringify(permissiveHostsInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				permissiveLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isDomainValid).toBe(true)
+		})
 
-	it('Fails if the license key has expired', async () => {
-		const expiredLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
-		const expiryDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 6) // 6 days ago
-		expiredLicenseInfo[PROPERTIES.EXPIRY_DATE] = expiryDate
-		const expiredLicenseKey = await generateLicenseKey(JSON.stringify(expiredLicenseInfo), keyPair)
-		const result = (await licenseManager.getLicenseFromKey(
-			expiredLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isAnnualLicenseExpired).toBe(true)
-	})
+		it('Succeeds if has an www domain specified, but at the apex domain', async () => {
+			// @ts-ignore
+			delete window.location
+			// @ts-ignore
+			window.location = new URL('https://example.com')
+
+			const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			permissiveHostsInfo[PROPERTIES.HOSTS] = ['www.example.com']
+			const permissiveLicenseKey = await generateLicenseKey(
+				JSON.stringify(permissiveHostsInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				permissiveLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isDomainValid).toBe(true)
+		})
 
-	it('Allows a grace period for expired licenses', async () => {
-		const almostExpiredLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
-		const expiryDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 5) // 5 days ago
-		almostExpiredLicenseInfo[PROPERTIES.EXPIRY_DATE] = expiryDate
-		const almostExpiredLicenseKey = await generateLicenseKey(
-			JSON.stringify(almostExpiredLicenseInfo),
-			keyPair
-		)
-		const result = (await licenseManager.getLicenseFromKey(
-			almostExpiredLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isAnnualLicenseExpired).toBe(false)
-	})
+		it('Succeeds if has a subdomain wildcard', async () => {
+			// @ts-ignore
+			delete window.location
+			// @ts-ignore
+			window.location = new URL('https://sub.example.com')
+
+			const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			permissiveHostsInfo[PROPERTIES.HOSTS] = ['*.example.com']
+			const permissiveLicenseKey = await generateLicenseKey(
+				JSON.stringify(permissiveHostsInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				permissiveLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isDomainValid).toBe(true)
+		})
 
-	// We mock the patch version to be in 2030 above.
-	it('Succeeds for perpetual license with correct version (and patch does not matter)', async () => {
-		const majorDate = new Date(publishDates.major)
-		const expiryDate = new Date(
-			majorDate.getFullYear(),
-			majorDate.getMonth(),
-			majorDate.getDate() + 100
-		)
-		const perpetualLicenseInfo = ['id', ['www.example.com'], FLAGS.PERPETUAL_LICENSE, expiryDate]
-		const almostExpiredLicenseKey = await generateLicenseKey(
-			JSON.stringify(perpetualLicenseInfo),
-			keyPair
-		)
-		const result = (await licenseManager.getLicenseFromKey(
-			almostExpiredLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isPerpetualLicense).toBe(true)
-		expect(result.isPerpetualLicenseExpired).toBe(false)
-	})
+		it('Succeeds if has a sub-subdomain wildcard', async () => {
+			// @ts-ignore
+			delete window.location
+			// @ts-ignore
+			window.location = new URL('https://pr-2408.sub.example.com')
+
+			const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			permissiveHostsInfo[PROPERTIES.HOSTS] = ['*.example.com']
+			const permissiveLicenseKey = await generateLicenseKey(
+				JSON.stringify(permissiveHostsInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				permissiveLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isDomainValid).toBe(true)
+		})
 
-	it('Fails for perpetual license past the release version', async () => {
-		const majorDate = new Date(publishDates.major)
-		const expiryDate = new Date(
-			majorDate.getFullYear(),
-			majorDate.getMonth(),
-			majorDate.getDate() - 100
-		)
-		const perpetualLicenseInfo = ['id', ['www.example.com'], FLAGS.PERPETUAL_LICENSE, expiryDate]
-		const almostExpiredLicenseKey = await generateLicenseKey(
-			JSON.stringify(perpetualLicenseInfo),
-			keyPair
-		)
-		const result = (await licenseManager.getLicenseFromKey(
-			almostExpiredLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isPerpetualLicense).toBe(true)
-		expect(result.isPerpetualLicenseExpired).toBe(true)
-	})
+		it('Succeeds if has a subdomain wildcard but on an apex domain', async () => {
+			// @ts-ignore
+			delete window.location
+			// @ts-ignore
+			window.location = new URL('https://example.com')
+
+			const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			permissiveHostsInfo[PROPERTIES.HOSTS] = ['*.example.com']
+			const permissiveLicenseKey = await generateLicenseKey(
+				JSON.stringify(permissiveHostsInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				permissiveLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isDomainValid).toBe(true)
+		})
 
-	it('Fails with invalid host', async () => {
-		// @ts-ignore
-		delete window.location
-		// @ts-ignore
-		window.location = new URL('https://www.foo.com')
+		it('Fails if has a subdomain wildcard isnt for the same base domain', async () => {
+			// @ts-ignore
+			delete window.location
+			// @ts-ignore
+			window.location = new URL('https://sub.example.com')
+
+			const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			permissiveHostsInfo[PROPERTIES.HOSTS] = ['*.foo.com']
+			const permissiveLicenseKey = await generateLicenseKey(
+				JSON.stringify(permissiveHostsInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				permissiveLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isDomainValid).toBe(false)
+		})
 
-		const expiredLicenseKey = await generateLicenseKey(STANDARD_LICENSE_INFO, keyPair)
-		const result = (await licenseManager.getLicenseFromKey(
-			expiredLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isDomainValid).toBe(false)
-	})
+		it('Succeeds if it is a vscode extension', async () => {
+			// @ts-ignore
+			delete window.location
+			// @ts-ignore
+			window.location = new URL(
+				'vscode-webview:vscode-webview://1ipd8pun8ud7nd7hv9d112g7evi7m10vak9vviuvia66ou6aibp3/index.html?id=6ec2dc7a-afe9-45d9-bd71-1749f9568d28&origin=955b256f-37e1-4a72-a2f4-ad633e88239c&swVersion=4&extensionId=tldraw-org.tldraw-vscode&platform=electron&vscode-resource-base-authority=vscode-resource.vscode-cdn.net&parentOrigin=vscode-file%3A%2F%2Fvscode-app'
+			)
+
+			const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			permissiveHostsInfo[PROPERTIES.HOSTS] = ['tldraw-org.tldraw-vscode']
+			const permissiveLicenseKey = await generateLicenseKey(
+				JSON.stringify(permissiveHostsInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				permissiveLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isDomainValid).toBe(true)
+		})
 
-	it('Succeeds if hosts is equal to only "*"', async () => {
-		// @ts-ignore
-		delete window.location
-		// @ts-ignore
-		window.location = new URL('https://www.foo.com')
-
-		const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
-		permissiveHostsInfo[PROPERTIES.HOSTS] = ['*']
-		const permissiveLicenseKey = await generateLicenseKey(
-			JSON.stringify(permissiveHostsInfo),
-			keyPair
-		)
-		const result = (await licenseManager.getLicenseFromKey(
-			permissiveLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isDomainValid).toBe(true)
+		it('Fails if it is a vscode extension with the wrong id', async () => {
+			// @ts-ignore
+			delete window.location
+			// @ts-ignore
+			window.location = new URL(
+				'vscode-webview:vscode-webview://1ipd8pun8ud7nd7hv9d112g7evi7m10vak9vviuvia66ou6aibp3/index.html?id=6ec2dc7a-afe9-45d9-bd71-1749f9568d28&origin=955b256f-37e1-4a72-a2f4-ad633e88239c&swVersion=4&extensionId=tldraw-org.tldraw-vscode&platform=electron&vscode-resource-base-authority=vscode-resource.vscode-cdn.net&parentOrigin=vscode-file%3A%2F%2Fvscode-app'
+			)
+
+			const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			permissiveHostsInfo[PROPERTIES.HOSTS] = ['blah-org.blah-vscode']
+			const permissiveLicenseKey = await generateLicenseKey(
+				JSON.stringify(permissiveHostsInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				permissiveLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isDomainValid).toBe(false)
+		})
 	})
 
-	it('Succeeds if has an apex domain specified', async () => {
-		// @ts-ignore
-		delete window.location
-		// @ts-ignore
-		window.location = new URL('https://www.example.com')
+	describe('License types and flags', () => {
+		it('Checks for internal license', async () => {
+			const internalLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			internalLicenseInfo[PROPERTIES.FLAGS] = FLAGS.INTERNAL_LICENSE
+			const internalLicenseKey = await generateLicenseKey(
+				JSON.stringify(internalLicenseInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				internalLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isInternalLicense).toBe(true)
+		})
 
-		const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
-		permissiveHostsInfo[PROPERTIES.HOSTS] = ['example.com']
-		const permissiveLicenseKey = await generateLicenseKey(
-			JSON.stringify(permissiveHostsInfo),
-			keyPair
-		)
-		const result = (await licenseManager.getLicenseFromKey(
-			permissiveLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isDomainValid).toBe(true)
-	})
+		it('Checks for license with watermark', async () => {
+			const withWatermarkLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			withWatermarkLicenseInfo[PROPERTIES.FLAGS] |= FLAGS.WITH_WATERMARK
+			const withWatermarkLicenseKey = await generateLicenseKey(
+				JSON.stringify(withWatermarkLicenseInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				withWatermarkLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isLicensedWithWatermark).toBe(true)
+		})
 
-	it('Succeeds if has an www domain specified, but at the apex domain', async () => {
-		// @ts-ignore
-		delete window.location
-		// @ts-ignore
-		window.location = new URL('https://example.com')
-
-		const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
-		permissiveHostsInfo[PROPERTIES.HOSTS] = ['www.example.com']
-		const permissiveLicenseKey = await generateLicenseKey(
-			JSON.stringify(permissiveHostsInfo),
-			keyPair
-		)
-		const result = (await licenseManager.getLicenseFromKey(
-			permissiveLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isDomainValid).toBe(true)
-	})
+		it('Checks for evaluation license', async () => {
+			const evaluationLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			evaluationLicenseInfo[PROPERTIES.FLAGS] = FLAGS.EVALUATION_LICENSE
+			const evaluationLicenseKey = await generateLicenseKey(
+				JSON.stringify(evaluationLicenseInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				evaluationLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isEvaluationLicense).toBe(true)
+			expect(result.isEvaluationLicenseExpired).toBe(false)
+		})
 
-	it('Succeeds if has a subdomain wildcard', async () => {
-		// @ts-ignore
-		delete window.location
-		// @ts-ignore
-		window.location = new URL('https://sub.example.com')
-
-		const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
-		permissiveHostsInfo[PROPERTIES.HOSTS] = ['*.example.com']
-		const permissiveLicenseKey = await generateLicenseKey(
-			JSON.stringify(permissiveHostsInfo),
-			keyPair
-		)
-		const result = (await licenseManager.getLicenseFromKey(
-			permissiveLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isDomainValid).toBe(true)
+		it('Detects when evaluation license has expired', async () => {
+			const expiredEvaluationLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			expiredEvaluationLicenseInfo[PROPERTIES.FLAGS] = FLAGS.EVALUATION_LICENSE
+			const expiredDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1) // 1 day ago
+			expiredEvaluationLicenseInfo[PROPERTIES.EXPIRY_DATE] = expiredDate.toISOString()
+
+			const expiredEvaluationLicenseKey = await generateLicenseKey(
+				JSON.stringify(expiredEvaluationLicenseInfo),
+				keyPair
+			)
+
+			// The getLicenseFromKey should return the expired state
+			const result = (await licenseManager.getLicenseFromKey(
+				expiredEvaluationLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isEvaluationLicense).toBe(true)
+			expect(result.isEvaluationLicenseExpired).toBe(true)
+		})
 	})
 
-	it('Succeeds if has a sub-subdomain wildcard', async () => {
-		// @ts-ignore
-		delete window.location
-		// @ts-ignore
-		window.location = new URL('https://pr-2408.sub.example.com')
-
-		const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
-		permissiveHostsInfo[PROPERTIES.HOSTS] = ['*.example.com']
-		const permissiveLicenseKey = await generateLicenseKey(
-			JSON.stringify(permissiveHostsInfo),
-			keyPair
-		)
-		const result = (await licenseManager.getLicenseFromKey(
-			permissiveLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isDomainValid).toBe(true)
-	})
+	describe('License expiry and grace period', () => {
+		it('Fails if the license key has expired beyond grace period', async () => {
+			const expiredLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			const expiryDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 40) // 40 days ago (beyond 30-day grace period)
+			expiredLicenseInfo[PROPERTIES.EXPIRY_DATE] = expiryDate
+			const expiredLicenseKey = await generateLicenseKey(
+				JSON.stringify(expiredLicenseInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				expiredLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isAnnualLicenseExpired).toBe(true)
+		})
 
-	it('Succeeds if has a subdomain wildcard but on an apex domain', async () => {
-		// @ts-ignore
-		delete window.location
-		// @ts-ignore
-		window.location = new URL('https://example.com')
-
-		const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
-		permissiveHostsInfo[PROPERTIES.HOSTS] = ['*.example.com']
-		const permissiveLicenseKey = await generateLicenseKey(
-			JSON.stringify(permissiveHostsInfo),
-			keyPair
-		)
-		const result = (await licenseManager.getLicenseFromKey(
-			permissiveLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isDomainValid).toBe(true)
-	})
+		it('Allows a grace period for expired licenses', async () => {
+			const almostExpiredLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			const expiryDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 5) // 5 days ago
+			almostExpiredLicenseInfo[PROPERTIES.EXPIRY_DATE] = expiryDate
+			const almostExpiredLicenseKey = await generateLicenseKey(
+				JSON.stringify(almostExpiredLicenseInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				almostExpiredLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isAnnualLicenseExpired).toBe(false)
+		})
 
-	it('Fails if has a subdomain wildcard isnt for the same base domain', async () => {
-		// @ts-ignore
-		delete window.location
-		// @ts-ignore
-		window.location = new URL('https://sub.example.com')
-
-		const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
-		permissiveHostsInfo[PROPERTIES.HOSTS] = ['*.foo.com']
-		const permissiveLicenseKey = await generateLicenseKey(
-			JSON.stringify(permissiveHostsInfo),
-			keyPair
-		)
-		const result = (await licenseManager.getLicenseFromKey(
-			permissiveLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isDomainValid).toBe(false)
-	})
+		it('Handles grace period correctly - 20 days expired should still be within grace period', async () => {
+			const expiredLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			const expiredDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 20) // 20 days ago
+			expiredLicenseInfo[PROPERTIES.EXPIRY_DATE] = expiredDate.toISOString()
+
+			const expiredLicenseKey = await generateLicenseKey(
+				JSON.stringify(expiredLicenseInfo),
+				keyPair
+			)
+
+			// Test the getLicenseFromKey method to verify grace period calculation
+			const result = (await licenseManager.getLicenseFromKey(
+				expiredLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isAnnualLicense).toBe(true)
+			expect(result.isAnnualLicenseExpired).toBe(false) // Within 30-day grace period
+			expect(result.daysSinceExpiry).toBe(20)
+		})
 
-	it('Succeeds if it is a vscode extension', async () => {
-		// @ts-ignore
-		delete window.location
-		// @ts-ignore
-		window.location = new URL(
-			'vscode-webview:vscode-webview://1ipd8pun8ud7nd7hv9d112g7evi7m10vak9vviuvia66ou6aibp3/index.html?id=6ec2dc7a-afe9-45d9-bd71-1749f9568d28&origin=955b256f-37e1-4a72-a2f4-ad633e88239c&swVersion=4&extensionId=tldraw-org.tldraw-vscode&platform=electron&vscode-resource-base-authority=vscode-resource.vscode-cdn.net&parentOrigin=vscode-file%3A%2F%2Fvscode-app'
-		)
-
-		const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
-		permissiveHostsInfo[PROPERTIES.HOSTS] = ['tldraw-org.tldraw-vscode']
-		const permissiveLicenseKey = await generateLicenseKey(
-			JSON.stringify(permissiveHostsInfo),
-			keyPair
-		)
-		const result = (await licenseManager.getLicenseFromKey(
-			permissiveLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isDomainValid).toBe(true)
-	})
+		it('Calculates days since expiry correctly', async () => {
+			const expiredLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			const expiredDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 15) // 15 days ago
+			expiredLicenseInfo[PROPERTIES.EXPIRY_DATE] = expiredDate.toISOString()
 
-	it('Fails if it is a vscode extension with the wrong id', async () => {
-		// @ts-ignore
-		delete window.location
-		// @ts-ignore
-		window.location = new URL(
-			'vscode-webview:vscode-webview://1ipd8pun8ud7nd7hv9d112g7evi7m10vak9vviuvia66ou6aibp3/index.html?id=6ec2dc7a-afe9-45d9-bd71-1749f9568d28&origin=955b256f-37e1-4a72-a2f4-ad633e88239c&swVersion=4&extensionId=tldraw-org.tldraw-vscode&platform=electron&vscode-resource-base-authority=vscode-resource.vscode-cdn.net&parentOrigin=vscode-file%3A%2F%2Fvscode-app'
-		)
-
-		const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
-		permissiveHostsInfo[PROPERTIES.HOSTS] = ['blah-org.blah-vscode']
-		const permissiveLicenseKey = await generateLicenseKey(
-			JSON.stringify(permissiveHostsInfo),
-			keyPair
-		)
-		const result = (await licenseManager.getLicenseFromKey(
-			permissiveLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isDomainValid).toBe(false)
-	})
+			const expiredLicenseKey = await generateLicenseKey(
+				JSON.stringify(expiredLicenseInfo),
+				keyPair
+			)
 
-	it('Checks for internal license', async () => {
-		const internalLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
-		internalLicenseInfo[PROPERTIES.FLAGS] = FLAGS.INTERNAL_LICENSE
-		const internalLicenseKey = await generateLicenseKey(
-			JSON.stringify(internalLicenseInfo),
-			keyPair
-		)
-		const result = (await licenseManager.getLicenseFromKey(
-			internalLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isInternalLicense).toBe(true)
+			const result = (await licenseManager.getLicenseFromKey(
+				expiredLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.daysSinceExpiry).toBe(15)
+		})
 	})
 
-	it('Checks for license with watermark', async () => {
-		const withWatermarkLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
-		withWatermarkLicenseInfo[PROPERTIES.FLAGS] |= FLAGS.WITH_WATERMARK
-		const withWatermarkLicenseKey = await generateLicenseKey(
-			JSON.stringify(withWatermarkLicenseInfo),
-			keyPair
-		)
-		const result = (await licenseManager.getLicenseFromKey(
-			withWatermarkLicenseKey
-		)) as ValidLicenseKeyResult
-		expect(result.isLicensedWithWatermark).toBe(true)
+	describe('Perpetual licenses', () => {
+		// We mock the patch version to be in 2030 above.
+		it('Succeeds for perpetual license with correct version (and patch does not matter)', async () => {
+			const majorDate = new Date(publishDates.major)
+			const expiryDate = new Date(
+				majorDate.getFullYear(),
+				majorDate.getMonth(),
+				majorDate.getDate() + 100
+			)
+			const perpetualLicenseInfo = ['id', ['www.example.com'], FLAGS.PERPETUAL_LICENSE, expiryDate]
+			const almostExpiredLicenseKey = await generateLicenseKey(
+				JSON.stringify(perpetualLicenseInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				almostExpiredLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isPerpetualLicense).toBe(true)
+			expect(result.isPerpetualLicenseExpired).toBe(false)
+		})
+
+		it('Fails for perpetual license past the release version', async () => {
+			const majorDate = new Date(publishDates.major)
+			const expiryDate = new Date(
+				majorDate.getFullYear(),
+				majorDate.getMonth(),
+				majorDate.getDate() - 100
+			)
+			const perpetualLicenseInfo = ['id', ['www.example.com'], FLAGS.PERPETUAL_LICENSE, expiryDate]
+			const almostExpiredLicenseKey = await generateLicenseKey(
+				JSON.stringify(perpetualLicenseInfo),
+				keyPair
+			)
+			const result = (await licenseManager.getLicenseFromKey(
+				almostExpiredLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isPerpetualLicense).toBe(true)
+			expect(result.isPerpetualLicenseExpired).toBe(true)
+		})
 	})
 })
 
@@ -475,6 +559,9 @@ function getDefaultLicenseResult(overrides: Partial<ValidLicenseKeyResult>): Val
 		isPerpetualLicenseExpired: false,
 		isLicenseParseable: true as const,
 		isLicensedWithWatermark: false,
+		isEvaluationLicense: false,
+		isEvaluationLicenseExpired: false,
+		daysSinceExpiry: 0,
 		// WatermarkManager does not check these fields, it relies on the calculated values like isAnnualLicenseExpired
 		license: {
 			id: 'id',
@@ -487,115 +574,291 @@ function getDefaultLicenseResult(overrides: Partial<ValidLicenseKeyResult>): Val
 	}
 }
 
-describe(isEditorUnlicensed, () => {
-	it('shows watermark when license is not parseable', () => {
-		const licenseResult = getDefaultLicenseResult({
-			// @ts-ignore
-			isLicenseParseable: false,
+describe('getLicenseState', () => {
+	describe('Development mode', () => {
+		it('returns "unlicensed" for unparseable license in development', () => {
+			const licenseResult = getDefaultLicenseResult({
+				// @ts-ignore
+				isLicenseParseable: false,
+			})
+			expect(getLicenseState(licenseResult, () => {}, true)).toBe('unlicensed')
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(true)
-	})
 
-	it('shows watermark when domain is not valid', () => {
-		const licenseResult = getDefaultLicenseResult({
-			isDomainValid: false,
+		it('returns "licensed" for invalid domain in development mode', () => {
+			const licenseResult = getDefaultLicenseResult({
+				isDomainValid: false,
+				isDevelopment: true,
+			})
+			expect(getLicenseState(licenseResult, () => {}, true)).toBe('licensed')
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(true)
-	})
 
-	it('shows watermark when annual license has expired', () => {
-		const licenseResult = getDefaultLicenseResult({
-			isAnnualLicense: true,
-			isAnnualLicenseExpired: true,
+		it('returns "licensed" for valid license in development mode', () => {
+			const licenseResult = getDefaultLicenseResult({
+				isDevelopment: true,
+			})
+			expect(getLicenseState(licenseResult, () => {}, true)).toBe('licensed')
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(true)
-	})
 
-	it('shows watermark when annual license has expired, even if dev mode', () => {
-		const licenseResult = getDefaultLicenseResult({
-			isAnnualLicense: true,
-			isAnnualLicenseExpired: true,
-			isDevelopment: true,
+		it('returns "unlicensed" for no license key in development (localhost)', () => {
+			const licenseResult = getDefaultLicenseResult({
+				// @ts-ignore
+				isLicenseParseable: false,
+				reason: 'no-key-provided',
+			})
+			expect(getLicenseState(licenseResult, () => {}, true)).toBe('unlicensed')
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(true)
 	})
 
-	it('shows watermark when perpetual license has expired', () => {
-		const licenseResult = getDefaultLicenseResult({
-			isPerpetualLicense: true,
-			isPerpetualLicenseExpired: true,
+	describe('Production mode - unlicensed states', () => {
+		it('returns "unlicensed-production" for unparseable license in production (invalid-license-key)', () => {
+			const messages: string[][] = []
+			const licenseResult = getDefaultLicenseResult({
+				// @ts-ignore
+				isLicenseParseable: false,
+				reason: 'invalid-license-key',
+			})
+			const result = getLicenseState(licenseResult, (msgs) => messages.push(msgs), false)
+			expect(result).toBe('unlicensed-production')
+
+			expect(messages).toHaveLength(1)
+			expect(messages[0]).toEqual([
+				'Invalid license key. tldraw requires a valid license for production use.',
+				'Please reach out to sales@tldraw.com to purchase a license.',
+			])
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(true)
-	})
 
-	it('does not show watermark when license is valid and not expired', () => {
-		const licenseResult = getDefaultLicenseResult({
-			isAnnualLicense: true,
-			isAnnualLicenseExpired: false,
-			isInternalLicense: false,
+		it('returns "unlicensed-production" for no license key in production', () => {
+			const messages: string[][] = []
+			const licenseResult = getDefaultLicenseResult({
+				// @ts-ignore
+				isLicenseParseable: false,
+				reason: 'no-key-provided',
+			})
+			const result = getLicenseState(licenseResult, (msgs) => messages.push(msgs), false)
+			expect(result).toBe('unlicensed-production')
+
+			expect(messages).toHaveLength(1)
+			expect(messages[0]).toEqual([
+				'No tldraw license key provided!',
+				'A license is required for production deployments.',
+				'Please reach out to sales@tldraw.com to purchase a license.',
+			])
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(false)
-	})
 
-	it('does not show watermark when perpetual license is valid and not expired', () => {
-		const licenseResult = getDefaultLicenseResult({
-			isPerpetualLicense: true,
-			isPerpetualLicenseExpired: false,
-			isInternalLicense: false,
+		it('returns "unlicensed-production" for invalid license key in production', () => {
+			const messages: string[][] = []
+			const licenseResult = getDefaultLicenseResult({
+				// @ts-ignore
+				isLicenseParseable: false,
+				reason: 'invalid-license-key',
+			})
+			const result = getLicenseState(licenseResult, (msgs) => messages.push(msgs), false)
+			expect(result).toBe('unlicensed-production')
+
+			expect(messages).toHaveLength(1)
+			expect(messages[0]).toEqual([
+				'Invalid license key. tldraw requires a valid license for production use.',
+				'Please reach out to sales@tldraw.com to purchase a license.',
+			])
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(false)
-	})
 
-	it('does not show watermark when in development mode', () => {
-		const licenseResult = getDefaultLicenseResult({
-			isDevelopment: true,
+		it('returns "unlicensed-production" for invalid domain in production', () => {
+			const messages: string[][] = []
+			const licenseResult = getDefaultLicenseResult({
+				isDomainValid: false,
+				isDevelopment: false,
+			})
+			const result = getLicenseState(licenseResult, (msgs) => messages.push(msgs), false)
+			expect(result).toBe('unlicensed-production')
+
+			expect(messages).toHaveLength(1)
+			expect(messages[0]).toEqual([
+				'License key is not valid for this domain.',
+				'A license is required for production deployments.',
+				'Please reach out to sales@tldraw.com to purchase a license.',
+			])
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(false)
-	})
 
-	it('does not show watermark when license is parseable and domain is valid', () => {
-		const licenseResult = getDefaultLicenseResult({
-			isLicenseParseable: true,
-			isDomainValid: true,
+		it('returns "unlicensed-production" for expired internal license with invalid domain', () => {
+			const messages: string[][] = []
+			const expiryDate = new Date(2023, 1, 1)
+			const licenseResult = getDefaultLicenseResult({
+				isAnnualLicense: true,
+				isAnnualLicenseExpired: true,
+				isInternalLicense: true,
+				isDomainValid: false,
+				expiryDate,
+			})
+			const result = getLicenseState(licenseResult, (msgs) => messages.push(msgs), false)
+			expect(result).toBe('unlicensed-production')
+
+			expect(messages).toHaveLength(1)
+			expect(messages[0]).toEqual([
+				'License key is not valid for this domain.',
+				'A license is required for production deployments.',
+				'Please reach out to sales@tldraw.com to purchase a license.',
+			])
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(false)
 	})
 
-	it('does not show watermark when license is parseable and domain is not valid and dev mode', () => {
-		const licenseResult = getDefaultLicenseResult({
-			isLicenseParseable: true,
-			isDomainValid: false,
-			isDevelopment: true,
+	describe('Valid licenses', () => {
+		it('returns "licensed" for valid annual license', () => {
+			const licenseResult = getDefaultLicenseResult({
+				isAnnualLicense: true,
+				isAnnualLicenseExpired: false,
+			})
+			expect(getLicenseState(licenseResult, () => {}, false)).toBe('licensed')
+		})
+
+		it('returns "licensed" for valid perpetual license', () => {
+			const licenseResult = getDefaultLicenseResult({
+				isPerpetualLicense: true,
+				isPerpetualLicenseExpired: false,
+			})
+			expect(getLicenseState(licenseResult, () => {}, false)).toBe('licensed')
+		})
+
+		it('returns "licensed-with-watermark" for watermarked license', () => {
+			const licenseResult = getDefaultLicenseResult({
+				isLicensedWithWatermark: true,
+			})
+			expect(getLicenseState(licenseResult, () => {}, false)).toBe('licensed-with-watermark')
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(false)
-	})
 
-	it('throws when an internal annual license has expired', () => {
-		const expiryDate = new Date(2023, 1, 1)
-		const licenseResult = getDefaultLicenseResult({
-			isAnnualLicense: true,
-			isAnnualLicenseExpired: true,
-			isInternalLicense: true,
-			expiryDate,
+		it('returns "licensed" for valid evaluation license', () => {
+			const licenseResult = getDefaultLicenseResult({
+				isEvaluationLicense: true,
+				isLicensedWithWatermark: false, // Evaluation license doesn't need WITH_WATERMARK flag
+				isAnnualLicense: false,
+				isPerpetualLicense: false,
+			})
+
+			// Evaluation license should be licensed but tracked (no watermark shown)
+			expect(getLicenseState(licenseResult, () => {}, false)).toBe('licensed')
+
+			// Verify evaluation license properties
+			expect(licenseResult.isEvaluationLicense).toBe(true)
+			expect(licenseResult.isLicensedWithWatermark).toBe(false) // No explicit watermark flag needed
+			expect(licenseResult.isAnnualLicense).toBe(false)
+			expect(licenseResult.isPerpetualLicense).toBe(false)
 		})
-		expect(() => isEditorUnlicensed(licenseResult)).toThrow(/License: Internal license expired/)
 	})
 
-	it('throws when an internal perpetual license has expired', () => {
-		const expiryDate = new Date(2023, 1, 1)
-		const licenseResult = getDefaultLicenseResult({
-			isPerpetualLicense: true,
-			isPerpetualLicenseExpired: true,
-			isInternalLicense: true,
-			expiryDate,
+	describe('Grace period handling', () => {
+		it('returns "licensed" for license 0-30 days past expiry', () => {
+			const messages: string[][] = []
+			const licenseResult = getDefaultLicenseResult({
+				isAnnualLicense: true,
+				isAnnualLicenseExpired: false, // Still within 30-day grace period
+				daysSinceExpiry: 20, // 20 days past expiry
+				isInternalLicense: false,
+			})
+
+			expect(getLicenseState(licenseResult, (msgs) => messages.push(msgs), false)).toBe('licensed')
+
+			expect(messages).toHaveLength(1)
+			expect(messages[0]).toEqual([
+				'Your tldraw license has expired.',
+				'License expired 20 days ago.',
+				'Please reach out to sales@tldraw.com to renew your license.',
+			])
 		})
-		expect(() => isEditorUnlicensed(licenseResult)).toThrow(/License: Internal license expired/)
 	})
 
-	it('shows watermark when license has that flag specified', () => {
-		const licenseResult = getDefaultLicenseResult({
-			isLicensedWithWatermark: true,
+	describe('Expired licenses', () => {
+		it('returns "expired" for license 30+ days past expiry', () => {
+			const messages: string[][] = []
+			const licenseResult = getDefaultLicenseResult({
+				isAnnualLicense: true,
+				isAnnualLicenseExpired: true, // Beyond 30-day grace period
+				daysSinceExpiry: 35, // 35 days past expiry
+				isInternalLicense: false,
+			})
+
+			expect(getLicenseState(licenseResult, (msgs) => messages.push(msgs), false)).toBe('expired')
+
+			expect(messages).toHaveLength(1)
+			expect(messages[0]).toEqual([
+				'Your tldraw license has been expired for more than 30 days!',
+				'Please reach out to sales@tldraw.com to renew your license.',
+			])
+		})
+
+		it('returns "expired" for expired annual license even in dev mode', () => {
+			const licenseResult = getDefaultLicenseResult({
+				isAnnualLicense: true,
+				isAnnualLicenseExpired: true,
+				isDevelopment: true,
+				isInternalLicense: false,
+			})
+			expect(getLicenseState(licenseResult, () => {}, true)).toBe('expired')
+		})
+
+		it('returns "expired" for expired perpetual license', () => {
+			const licenseResult = getDefaultLicenseResult({
+				isPerpetualLicense: true,
+				isPerpetualLicenseExpired: true,
+				isInternalLicense: false,
+			})
+			expect(getLicenseState(licenseResult, () => {}, false)).toBe('expired')
+		})
+
+		it('returns "expired" for expired evaluation license', () => {
+			const messages: string[][] = []
+			const licenseResult = getDefaultLicenseResult({
+				isEvaluationLicense: true,
+				isEvaluationLicenseExpired: true,
+				isAnnualLicense: false,
+				isPerpetualLicense: false,
+			})
+
+			expect(getLicenseState(licenseResult, (msgs) => messages.push(msgs), false)).toBe('expired')
+
+			expect(messages).toHaveLength(1)
+			expect(messages[0]).toEqual([
+				'Your tldraw evaluation license has expired!',
+				'Please reach out to sales@tldraw.com to purchase a full license.',
+			])
+		})
+
+		it('returns "expired" for expired internal annual license with valid domain', () => {
+			const messages: string[][] = []
+			const expiryDate = new Date(2023, 1, 1)
+			const licenseResult = getDefaultLicenseResult({
+				isAnnualLicense: true,
+				isAnnualLicenseExpired: true,
+				isInternalLicense: true,
+				isDomainValid: true,
+				expiryDate,
+			})
+
+			expect(getLicenseState(licenseResult, (msgs) => messages.push(msgs), false)).toBe('expired')
+
+			expect(messages).toHaveLength(1)
+			expect(messages[0]).toEqual([
+				'Your tldraw license has been expired for more than 30 days!',
+				'Please reach out to sales@tldraw.com to renew your license.',
+			])
+		})
+
+		it('returns "expired" for expired internal perpetual license with valid domain', () => {
+			const messages: string[][] = []
+			const expiryDate = new Date(2023, 1, 1)
+			const licenseResult = getDefaultLicenseResult({
+				isPerpetualLicense: true,
+				isPerpetualLicenseExpired: true,
+				isInternalLicense: true,
+				isDomainValid: true,
+				expiryDate,
+			})
+
+			expect(getLicenseState(licenseResult, (msgs) => messages.push(msgs), false)).toBe('expired')
+
+			expect(messages).toHaveLength(1)
+			expect(messages[0]).toEqual([
+				'Your tldraw license has been expired for more than 30 days!',
+				'Please reach out to sales@tldraw.com to renew your license.',
+			])
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(false)
 	})
 })