@designbasekorea/figma-license-core 0.1.0 → 0.3.0

package/dist/index.umd.js

@@ -8,6 +8,9 @@
     (function (LicenseErrorCode) {
         LicenseErrorCode["ACTIVATION_LIMIT_REACHED"] = "ACTIVATION_LIMIT_REACHED";
         LicenseErrorCode["INVALID_LICENSE"] = "INVALID_LICENSE";
+        LicenseErrorCode["LICENSE_EXPIRED"] = "LICENSE_EXPIRED";
+        LicenseErrorCode["LICENSE_REVOKED"] = "LICENSE_REVOKED";
+        LicenseErrorCode["RATE_LIMITED"] = "RATE_LIMITED";
         LicenseErrorCode["PRODUCT_MISMATCH"] = "PRODUCT_MISMATCH";
         LicenseErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
         LicenseErrorCode["STORAGE_ERROR"] = "STORAGE_ERROR";
@@ -31,10 +34,18 @@
         if (typeof input === 'string') {
             return input;
         }
-        if (typeof input === 'object' && 'message' in input) {
-            const maybeMessage = input.message;
-            if (typeof maybeMessage === 'string') {
-                return maybeMessage;
+        if (typeof input === 'object') {
+            const objectInput = input;
+            if (objectInput.raw) {
+                return asText(objectInput.raw);
+            }
+            if (objectInput.body) {
+                return asText(objectInput.body);
+            }
+            const fields = [objectInput.message, objectInput.errorCode, objectInput.code, objectInput.status]
+                .filter((value) => typeof value === 'string' && value.trim() !== '');
+            if (fields.length > 0) {
+                return fields.join(' ');
             }
         }
         try {
@@ -52,13 +63,32 @@
             || normalized.includes('already activated on maximum')) {
             return exports.LicenseErrorCode.ACTIVATION_LIMIT_REACHED;
         }
+        if (normalized.includes('rate limited')
+            || normalized.includes('rate_limited')
+            || normalized.includes('too many requests')
+            || normalized.includes('too_many_requests')
+            || normalized.includes('429')) {
+            return exports.LicenseErrorCode.RATE_LIMITED;
+        }
+        if (normalized.includes('expired') || normalized.includes('expiration') || normalized.includes('license_expired')) {
+            return exports.LicenseErrorCode.LICENSE_EXPIRED;
+        }
+        if (normalized.includes('revoked')
+            || normalized.includes('license_revoked')
+            || normalized.includes('cancelled')
+            || normalized.includes('canceled')) {
+            return exports.LicenseErrorCode.LICENSE_REVOKED;
+        }
         if (normalized.includes('invalid license')
             || normalized.includes('not found')
             || normalized.includes('not valid')
             || normalized.includes('license key is invalid')) {
             return exports.LicenseErrorCode.INVALID_LICENSE;
         }
-        if (normalized.includes('product mismatch') || normalized.includes('wrong product')) {
+        if (normalized.includes('product mismatch')
+            || normalized.includes('product_mismatch')
+            || normalized.includes('product_not_allowed')
+            || normalized.includes('wrong product')) {
             return exports.LicenseErrorCode.PRODUCT_MISMATCH;
         }
         if (normalized.includes('network')
@@ -79,7 +109,9 @@
         const text = asText(error);
         const message = text.trim() || fallbackMessage;
         const code = inferCode(message);
-        return new LicenseCoreError(code, message, error, code === exports.LicenseErrorCode.NETWORK_ERROR || code === exports.LicenseErrorCode.SERVER_ERROR);
+        return new LicenseCoreError(code, message, error, code === exports.LicenseErrorCode.NETWORK_ERROR
+            || code === exports.LicenseErrorCode.SERVER_ERROR
+            || code === exports.LicenseErrorCode.RATE_LIMITED);
     }
     function isActivationLimitReached(activationLimit, activationUsage) {
         if (activationLimit <= 0) {
@@ -91,10 +123,19 @@
     const STORAGE_KEYS = {
         paymentStatus: 'paymentStatus',
         licenseKey: 'licenseKey',
+        instanceId: 'instanceId',
         activationLimit: 'activationLimit',
         activationUsage: 'activationUsage',
         usageCount: 'usageCount',
+        previousUsageCount: 'previousUsageCount',
+        usageWindowKey: 'usageWindowKey',
+        planTier: 'planTier',
         lastVerifiedAt: 'lastVerifiedAt',
+        licenseStatus: 'licenseStatus',
+        licenseSource: 'licenseSource',
+        accessScope: 'accessScope',
+        expiresAt: 'expiresAt',
+        validationMessage: 'validationMessage',
     };
     const DEFAULT_USAGE_LIMIT = 20;
     const MASTER_CODE_ACTIVATION_LIMIT = 999999;
@@ -113,6 +154,31 @@
     function toText(value) {
         return typeof value === 'string' ? value : '';
     }
+    function validationMessage(result) {
+        if (result.message) {
+            return result.message;
+        }
+        const status = (result.licenseStatus || result.errorCode || '').toLowerCase();
+        switch (status) {
+            case 'revoked':
+            case 'license_revoked':
+                return '이 멤버십 라이선스는 철회되었습니다.';
+            case 'expired':
+            case 'license_expired':
+                return '멤버십 라이선스가 만료되었습니다. YouTube 커뮤니티에서 이번 달 키를 확인해 주세요.';
+            case 'not_started':
+                return '이 멤버십 라이선스는 아직 시작되지 않았습니다.';
+            case 'rate_limited':
+            case 'rate_limited_error':
+                return '라이선스 확인 요청이 너무 많습니다. 잠시 후 다시 시도해 주세요.';
+            case 'product_not_allowed':
+                return '이 라이선스는 현재 플러그인에서 사용할 수 없습니다.';
+            case 'network_error':
+                return '라이선스 서버에 연결할 수 없습니다. 잠시 후 다시 시도해 주세요.';
+            default:
+                return '라이선스가 더 이상 유효하지 않습니다.';
+        }
+    }
     function toPaymentStatus(value) {
         if (value === 'PAID' || value === 'UNPAID' || value === 'FREE') {
             return value;
@@ -122,10 +188,77 @@
     function normalizeProductId(productId) {
         return productId.trim().toLowerCase();
     }
+    function normalizeTier(tier) {
+        return tier.trim() || 'FREE';
+    }
+    function normalizeUsageReset(reset) {
+        if (reset === 'daily' || reset === 'weekly' || reset === 'monthly' || reset === 'none') {
+            return reset;
+        }
+        return 'none';
+    }
+    function toDateKey(date, period) {
+        if (period === 'none') {
+            return 'lifetime';
+        }
+        const year = date.getUTCFullYear();
+        const month = `${date.getUTCMonth() + 1}`.padStart(2, '0');
+        const day = `${date.getUTCDate()}`.padStart(2, '0');
+        if (period === 'monthly') {
+            return `${year}-${month}`;
+        }
+        if (period === 'weekly') {
+            // ISO weeks start on Monday and keep the week-year at the Thursday of
+            // the current week. Using UTC avoids a reset moving at local DST changes.
+            const dayOfWeek = date.getUTCDay() || 7;
+            const thursday = new Date(Date.UTC(year, date.getUTCMonth(), date.getUTCDate()));
+            thursday.setUTCDate(thursday.getUTCDate() + (4 - dayOfWeek));
+            const weekYear = thursday.getUTCFullYear();
+            const firstThursday = new Date(Date.UTC(weekYear, 0, 4));
+            const firstDay = firstThursday.getUTCDay() || 7;
+            firstThursday.setUTCDate(firstThursday.getUTCDate() + (4 - firstDay));
+            const week = 1 + Math.round((thursday.getTime() - firstThursday.getTime()) / 604800000);
+            return `${weekYear}-W${String(week).padStart(2, '0')}`;
+        }
+        return `${year}-${month}-${day}`;
+    }
+    function normalizePolicy(config) {
+        const rawPolicy = config.policy || {};
+        const freeTier = normalizeTier(rawPolicy.freeTier || 'FREE');
+        const paidTier = normalizeTier(rawPolicy.paidTier || 'PAID');
+        const defaultTier = normalizeTier(rawPolicy.defaultTier || freeTier);
+        const usageByTier = {
+            [freeTier]: {
+                limit: Math.max(config.usageLimit ?? DEFAULT_USAGE_LIMIT, 0),
+                reset: 'none',
+            },
+            [paidTier]: {
+                limit: 'unlimited',
+                reset: 'none',
+            },
+            ...(rawPolicy.usageByTier || {}),
+        };
+        Object.keys(usageByTier).forEach((tier) => {
+            usageByTier[tier] = {
+                limit: usageByTier[tier].limit === 'unlimited'
+                    ? 'unlimited'
+                    : Math.max(toNonNegativeNumber(usageByTier[tier].limit, 0), 0),
+                reset: normalizeUsageReset(usageByTier[tier].reset),
+            };
+        });
+        return {
+            defaultTier,
+            freeTier,
+            paidTier,
+            usageByTier,
+            featuresByTier: rawPolicy.featuresByTier || {},
+        };
+    }
     class LicenseCore {
         constructor(config, deps) {
             this.config = config;
             this.deps = deps;
+            this.usageMutation = Promise.resolve();
             if (!config.productId.trim()) {
                 throw new Error('LicenseConfig.productId is required.');
             }
@@ -135,14 +268,117 @@
             if (!config.instanceName.trim()) {
                 throw new Error('LicenseConfig.instanceName is required.');
             }
-            this.usageLimit = Math.max(config.usageLimit ?? DEFAULT_USAGE_LIMIT, 0);
+            this.policy = normalizePolicy(config);
             this.storagePrefix = config.storagePrefix?.trim() || `${config.instanceName}:${config.productId}`;
         }
         async initialize() {
-            return this.loadState();
+            let state = await this.getStatus();
+            if (state.paymentStatus === 'PAID' && state.licenseKey && state.licenseKey !== this.config.masterCode) {
+                try {
+                    const validateResult = this.deps.transport.validate
+                        ? await this.deps.transport.validate({
+                            licenseKey: state.licenseKey,
+                            productId: this.config.productId,
+                            instanceName: this.config.instanceName,
+                            instanceId: state.instanceId,
+                        })
+                        : await this.deps.transport.verify({
+                            licenseKey: state.licenseKey,
+                            productId: this.config.productId,
+                            instanceName: this.config.instanceName,
+                        });
+                    if (!validateResult.valid) {
+                        state = await this.markValidationFailure(state, validationMessage(validateResult), validateResult.errorCode || validateResult.licenseStatus);
+                    }
+                    else {
+                        state = await this.applyValidationResult(state, validateResult);
+                    }
+                }
+                catch (error) {
+                    const mappedError = mapLicenseError(error, '라이선스 검증 요청에 실패했습니다.');
+                    state = await this.markValidationFailure(state, mappedError.message, mappedError.code);
+                }
+            }
+            return this.applyUsageWindowResetIfNeeded(state);
+        }
+        async resetLicenseState() {
+            const current = await this.getStatus();
+            const freeReset = this.getUsagePolicy(this.policy.freeTier).reset;
+            const previousUsageCount = current.previousUsageCount ?? 0;
+            const nextState = {
+                ...current,
+                paymentStatus: 'FREE',
+                planTier: this.policy.freeTier,
+                usageWindowKey: toDateKey(new Date(), freeReset),
+                licenseKey: '',
+                instanceId: '',
+                activationLimit: 0,
+                activationUsage: 0,
+                usageCount: previousUsageCount,
+                lastVerifiedAt: undefined,
+                licenseStatus: undefined,
+                licenseSource: undefined,
+                accessScope: undefined,
+                expiresAt: undefined,
+                validationMessage: undefined,
+            };
+            await this.persistState(nextState);
+            return nextState;
+        }
+        async applyValidationResult(current, result) {
+            const nextState = {
+                ...current,
+                paymentStatus: 'PAID',
+                activationLimit: result.activationLimit ?? current.activationLimit,
+                activationUsage: result.activationUsage ?? current.activationUsage,
+                licenseStatus: result.licenseStatus || 'active',
+                licenseSource: result.licenseSource || current.licenseSource,
+                accessScope: result.accessScope || current.accessScope,
+                expiresAt: result.expiresAt ?? current.expiresAt,
+                validationMessage: result.message || undefined,
+                lastVerifiedAt: new Date().toISOString(),
+            };
+            await this.persistState(nextState);
+            return nextState;
+        }
+        async markValidationFailure(current, message, errorCode) {
+            const freeReset = this.getUsagePolicy(this.policy.freeTier).reset;
+            const nextState = {
+                ...current,
+                paymentStatus: 'UNPAID',
+                planTier: this.policy.freeTier,
+                usageWindowKey: toDateKey(new Date(), freeReset),
+                activationLimit: 0,
+                activationUsage: 0,
+                usageCount: current.previousUsageCount ?? current.usageCount,
+                licenseStatus: errorCode || 'invalid',
+                accessScope: undefined,
+                expiresAt: undefined,
+                validationMessage: message,
+                lastVerifiedAt: new Date().toISOString(),
+            };
+            await this.persistState(nextState);
+            return nextState;
         }
         async getStatus() {
-            return this.loadState();
+            const state = await this.loadState();
+            return this.applyUsageWindowResetIfNeeded(state);
+        }
+        async getLicenseSummary() {
+            const state = await this.getStatus();
+            return {
+                paymentStatus: state.paymentStatus,
+                planTier: this.resolveTier(state),
+                licenseKey: state.licenseKey,
+                hasLicenseKey: Boolean(state.licenseKey),
+                isLicenseRegistered: this.isLicenseRegisteredState(state),
+                licenseStatus: state.licenseStatus,
+                licenseSource: state.licenseSource,
+                accessScope: state.accessScope,
+                expiresAt: state.expiresAt,
+                lastVerifiedAt: state.lastVerifiedAt,
+                validationMessage: state.validationMessage,
+            };
         }
         async verifyLicense(licenseKey) {
             const trimmedLicenseKey = licenseKey.trim();
@@ -150,18 +386,27 @@
                 throw new LicenseCoreError(exports.LicenseErrorCode.INVALID_LICENSE, '라이선스 키를 입력해 주세요.');
             }
             if (this.config.masterCode && trimmedLicenseKey === this.config.masterCode) {
-                const current = await this.loadState();
+                const current = await this.getStatus();
                 const nextState = {
                     ...current,
                     paymentStatus: 'PAID',
+                    planTier: this.policy.paidTier,
+                    usageWindowKey: toDateKey(new Date(), this.getUsagePolicy(this.policy.paidTier).reset),
                     licenseKey: trimmedLicenseKey,
+                    instanceId: 'master-instance',
                     activationLimit: MASTER_CODE_ACTIVATION_LIMIT,
                     activationUsage: 0,
+                    previousUsageCount: current.usageCount,
                     lastVerifiedAt: new Date().toISOString(),
+                    licenseStatus: 'active',
+                    licenseSource: 'master',
+                    accessScope: 'all-products',
+                    expiresAt: undefined,
+                    validationMessage: undefined,
                 };
                 await this.persistState(nextState);
                 await this.notify('마스터 코드로 라이선스가 활성화되었습니다.');
-                return nextState;
+                return this.applyUsageWindowResetIfNeeded(nextState);
             }
             let verifyResult;
             try {
@@ -175,7 +420,7 @@
                 throw mapLicenseError(error, '라이선스 검증 요청에 실패했습니다.');
             }
             if (!verifyResult.valid) {
-                throw mapLicenseError(verifyResult.raw ?? verifyResult.message, '유효하지 않은 라이선스 키입니다.');
+                throw mapLicenseError(verifyResult.raw ?? { message: verifyResult.message, errorCode: verifyResult.errorCode }, '유효하지 않은 라이선스 키입니다.');
             }
             if (verifyResult.productId
                 && normalizeProductId(verifyResult.productId) !== normalizeProductId(this.config.productId)) {
@@ -186,21 +431,32 @@
             if (isActivationLimitReached(activationLimit, activationUsage)) {
                 throw new LicenseCoreError(exports.LicenseErrorCode.ACTIVATION_LIMIT_REACHED, '활성화 가능한 기기 수를 모두 사용했습니다. 기존 기기를 비활성화한 뒤 다시 시도해 주세요.', verifyResult);
             }
-            const current = await this.loadState();
+            const current = await this.getStatus();
+            const planTier = normalizeTier(verifyResult.planTier || this.policy.paidTier);
+            const usageReset = this.getUsagePolicy(planTier).reset;
             const nextState = {
                 ...current,
                 paymentStatus: 'PAID',
-                licenseKey: trimmedLicenseKey,
+                planTier,
+                usageWindowKey: toDateKey(new Date(), usageReset),
+                licenseKey: verifyResult.licenseKey || trimmedLicenseKey,
+                instanceId: verifyResult.instanceId || '',
                 activationLimit,
                 activationUsage,
+                previousUsageCount: current.usageCount,
                 lastVerifiedAt: new Date().toISOString(),
+                licenseStatus: verifyResult.licenseStatus || 'active',
+                licenseSource: verifyResult.licenseSource,
+                accessScope: verifyResult.accessScope,
+                expiresAt: verifyResult.expiresAt,
+                validationMessage: verifyResult.message || undefined,
             };
             await this.persistState(nextState);
             await this.notify(verifyResult.message || '라이선스가 활성화되었습니다.');
-            return nextState;
+            return this.applyUsageWindowResetIfNeeded(nextState);
         }
         async deactivateLicense() {
-            const current = await this.loadState();
+            const current = await this.getStatus();
             if (!current.licenseKey) {
                 return current;
             }
@@ -208,6 +464,7 @@
                 licenseKey: current.licenseKey,
                 productId: this.config.productId,
                 instanceName: this.config.instanceName,
+                instanceId: current.instanceId,
             };
             if (!this.config.masterCode || current.licenseKey !== this.config.masterCode) {
                 try {
@@ -220,24 +477,19 @@
                     throw mapLicenseError(error, '라이선스 비활성화 요청에 실패했습니다.');
                 }
             }
-            const nextState = {
-                ...current,
-                paymentStatus: 'FREE',
-                licenseKey: '',
-                activationLimit: 0,
-                activationUsage: 0,
-                lastVerifiedAt: undefined,
-            };
-            await this.persistState(nextState);
+            const nextState = await this.resetLicenseState();
             await this.notify('라이선스가 비활성화되었습니다.');
-            return nextState;
+            return this.applyUsageWindowResetIfNeeded(nextState);
         }
         async incrementUsage(amount = 1) {
-            const current = await this.loadState();
+            const current = await this.getStatus();
             if (current.paymentStatus === 'PAID') {
                 return current;
             }
-            const increasedAmount = Math.max(0, amount);
+            const increasedAmount = Number.isFinite(amount) ? Math.max(0, amount) : 0;
+            if (increasedAmount === 0) {
+                return current;
+            }
             const nextState = {
                 ...current,
                 usageCount: current.usageCount + increasedAmount,
@@ -245,64 +497,198 @@
             await this.persistState(nextState);
             return nextState;
         }
-        async canUseFeature() {
-            const state = await this.loadState();
-            return this.resolveUsageAccess(state);
+        async canUseFeature(featureKey, amount = 1) {
+            const state = await this.getStatus();
+            return this.resolveUsageAccess(state, featureKey, amount);
         }
-        resolveUsageAccess(state) {
-            if (state.paymentStatus === 'PAID') {
+        async consumeUsage(amount = 1, featureKey) {
+            const execute = async () => {
+                const state = await this.getStatus();
+                const requestedAmount = Number.isFinite(amount) ? Math.max(0, amount) : 0;
+                const access = this.resolveUsageAccess(state, featureKey, requestedAmount);
+                if (!access.allowed || requestedAmount <= 0) {
+                    return { state, access, consumed: false };
+                }
+                const updatedState = await this.incrementUsage(requestedAmount);
+                const updatedAccess = this.resolveUsageAccess(updatedState, featureKey, requestedAmount);
                 return {
-                    allowed: true,
+                    state: updatedState,
+                    access: updatedAccess,
+                    consumed: true,
+                };
+            };
+            // Figma can deliver duplicate UI events while a panel remounts. Serialize
+            // the check + persist pair so two concurrent requests cannot overspend the
+            // same local allowance.
+            const pending = this.usageMutation.then(execute, execute);
+            this.usageMutation = pending.then(() => undefined, () => undefined);
+            return pending;
+        }
+        resolveUsageAccess(state, featureKey, amount = 1) {
+            const tier = this.resolveTier(state);
+            const usagePolicy = this.getUsagePolicy(tier);
+            const featureAllowed = this.isFeatureAllowed(tier, featureKey);
+            const isLicensed = this.isLicenseRegisteredState(state);
+            const requested = Number.isFinite(amount) && amount > 0 ? amount : 1;
+            const used = state.usageCount;
+            if (usagePolicy.limit === 'unlimited') {
+                return {
+                    allowed: featureAllowed,
                     remaining: Number.POSITIVE_INFINITY,
+                    used,
+                    limit: 'unlimited',
+                    reset: usagePolicy.reset,
+                    requested,
+                    tier,
+                    hasLicenseKey: Boolean(state.licenseKey),
+                    isLicenseRegistered: isLicensed,
+                    featureAllowed,
+                    featureKey,
+                    reason: featureAllowed ? undefined : 'FEATURE_NOT_ALLOWED',
                 };
             }
-            const remaining = Math.max(this.usageLimit - state.usageCount, 0);
+            const remaining = Math.max(usagePolicy.limit - used, 0);
+            const usageAllowed = remaining >= requested;
+            const allowed = featureAllowed && usageAllowed;
             return {
-                allowed: remaining > 0,
+                allowed,
                 remaining,
+                used,
+                limit: usagePolicy.limit,
+                reset: usagePolicy.reset,
+                requested,
+                tier,
+                hasLicenseKey: Boolean(state.licenseKey),
+                isLicenseRegistered: isLicensed,
+                featureAllowed,
+                featureKey,
+                reason: featureAllowed ? (usageAllowed ? undefined : 'USAGE_LIMIT_REACHED') : 'FEATURE_NOT_ALLOWED',
             };
         }
-        getUsageLimit() {
-            return this.usageLimit;
+        getUsageLimit(state) {
+            const tier = state ? this.resolveTier(state) : this.policy.freeTier;
+            return this.getUsagePolicy(tier).limit;
         }
         getStoragePrefix() {
             return this.storagePrefix;
         }
+        resolveTier(state) {
+            const storedTier = normalizeTier(state.planTier || '');
+            {
+                return storedTier;
+            }
+        }
+        getUsagePolicy(tier) {
+            return this.policy.usageByTier[tier]
+                || this.policy.usageByTier[this.policy.defaultTier]
+                || { limit: 'unlimited', reset: 'none' };
+        }
+        isFeatureAllowed(tier, featureKey) {
+            if (!featureKey) {
+                return true;
+            }
+            const policy = this.policy.featuresByTier[tier];
+            if (!policy) {
+                return true;
+            }
+            if (policy.deny?.includes(featureKey)) {
+                return false;
+            }
+            if (policy.allow && policy.allow.length > 0) {
+                return policy.allow.includes(featureKey);
+            }
+            return policy.defaultAllowed ?? true;
+        }
+        isLicenseRegisteredState(state) {
+            const status = state.licenseStatus?.toLowerCase();
+            const invalidStatuses = ['invalid', 'inactive', 'expired', 'revoked', 'unpaid'];
+            return state.paymentStatus === 'PAID'
+                && Boolean(state.licenseKey)
+                && !invalidStatuses.includes(status || '');
+        }
         storageKey(name) {
             return `${this.storagePrefix}:${STORAGE_KEYS[name]}`;
         }
         async loadState() {
             try {
-                const [paymentStatus, licenseKey, activationLimit, activationUsage, usageCount, lastVerifiedAt,] = await Promise.all([
+                const [paymentStatus, licenseKey, instanceId, activationLimit, activationUsage, usageCount, previousUsageCount, usageWindowKey, planTier, lastVerifiedAt, licenseStatus, licenseSource, accessScope, expiresAt, validationMessage,] = await Promise.all([
                     this.deps.storage.get(this.storageKey('paymentStatus')),
                     this.deps.storage.get(this.storageKey('licenseKey')),
+                    this.deps.storage.get(this.storageKey('instanceId')),
                     this.deps.storage.get(this.storageKey('activationLimit')),
                     this.deps.storage.get(this.storageKey('activationUsage')),
                     this.deps.storage.get(this.storageKey('usageCount')),
+                    this.deps.storage.get(this.storageKey('previousUsageCount')),
+                    this.deps.storage.get(this.storageKey('usageWindowKey')),
+                    this.deps.storage.get(this.storageKey('planTier')),
                     this.deps.storage.get(this.storageKey('lastVerifiedAt')),
+                    this.deps.storage.get(this.storageKey('licenseStatus')),
+                    this.deps.storage.get(this.storageKey('licenseSource')),
+                    this.deps.storage.get(this.storageKey('accessScope')),
+                    this.deps.storage.get(this.storageKey('expiresAt')),
+                    this.deps.storage.get(this.storageKey('validationMessage')),
                 ]);
+                const normalizedPaymentStatus = toPaymentStatus(paymentStatus);
+                const resolvedTier = normalizeTier(toText(planTier)
+                    || (normalizedPaymentStatus === 'PAID' ? this.policy.paidTier : this.policy.freeTier));
+                const usageReset = this.getUsagePolicy(resolvedTier).reset;
                 return {
-                    paymentStatus: toPaymentStatus(paymentStatus),
+                    paymentStatus: normalizedPaymentStatus,
                     licenseKey: toText(licenseKey),
+                    instanceId: toText(instanceId),
                     activationLimit: toNonNegativeNumber(activationLimit, 0),
                     activationUsage: toNonNegativeNumber(activationUsage, 0),
                     usageCount: toNonNegativeNumber(usageCount, 0),
+                    previousUsageCount: toNonNegativeNumber(previousUsageCount, 0),
+                    usageWindowKey: toText(usageWindowKey) || toDateKey(new Date(), usageReset),
+                    planTier: resolvedTier,
                     lastVerifiedAt: toText(lastVerifiedAt) || undefined,
+                    licenseStatus: toText(licenseStatus) || undefined,
+                    licenseSource: toText(licenseSource) || undefined,
+                    accessScope: toText(accessScope) || undefined,
+                    expiresAt: toText(expiresAt) || undefined,
+                    validationMessage: toText(validationMessage) || undefined,
                 };
             }
             catch (error) {
                 throw new LicenseCoreError(exports.LicenseErrorCode.STORAGE_ERROR, '라이선스 상태를 불러오지 못했습니다.', error, true);
             }
         }
+        async applyUsageWindowResetIfNeeded(state) {
+            const tier = this.resolveTier(state);
+            const usageReset = this.getUsagePolicy(tier).reset;
+            const expectedWindowKey = toDateKey(new Date(), usageReset);
+            const requiresUsageReset = usageReset !== 'none' && state.usageWindowKey !== expectedWindowKey;
+            const requiresWindowMigration = state.usageWindowKey !== expectedWindowKey;
+            if (!requiresUsageReset && !requiresWindowMigration) {
+                return state;
+            }
+            const nextState = {
+                ...state,
+                usageWindowKey: expectedWindowKey,
+                usageCount: requiresUsageReset ? 0 : state.usageCount,
+            };
+            await this.persistState(nextState);
+            return nextState;
+        }
         async persistState(state) {
             try {
                 await Promise.all([
                     this.deps.storage.set(this.storageKey('paymentStatus'), state.paymentStatus),
                     this.deps.storage.set(this.storageKey('licenseKey'), state.licenseKey),
+                    this.deps.storage.set(this.storageKey('instanceId'), state.instanceId || ''),
                     this.deps.storage.set(this.storageKey('activationLimit'), state.activationLimit),
                     this.deps.storage.set(this.storageKey('activationUsage'), state.activationUsage),
                     this.deps.storage.set(this.storageKey('usageCount'), state.usageCount),
+                    this.deps.storage.set(this.storageKey('previousUsageCount'), state.previousUsageCount || 0),
+                    this.deps.storage.set(this.storageKey('usageWindowKey'), state.usageWindowKey),
+                    this.deps.storage.set(this.storageKey('planTier'), state.planTier),
                     this.deps.storage.set(this.storageKey('lastVerifiedAt'), state.lastVerifiedAt || ''),
+                    this.deps.storage.set(this.storageKey('licenseStatus'), state.licenseStatus || ''),
+                    this.deps.storage.set(this.storageKey('licenseSource'), state.licenseSource || ''),
+                    this.deps.storage.set(this.storageKey('accessScope'), state.accessScope || ''),
+                    this.deps.storage.set(this.storageKey('expiresAt'), state.expiresAt || ''),
+                    this.deps.storage.set(this.storageKey('validationMessage'), state.validationMessage || ''),
                 ]);
             }
             catch (error) {
@@ -352,18 +738,47 @@
         }
         return undefined;
     }
-    function asRecord(value) {
+    function readBooleanField(raw, keys) {
+        if (!raw || typeof raw !== 'object') {
+            return undefined;
+        }
+        for (const key of keys) {
+            const value = raw[key];
+            if (typeof value === 'boolean') {
+                return value;
+            }
+            if (typeof value === 'string') {
+                const normalized = value.trim().toLowerCase();
+                if (['true', '1', 'yes', 'active', 'valid', 'success'].includes(normalized)) {
+                    return true;
+                }
+                if (['false', '0', 'no', 'inactive', 'invalid', 'revoked', 'expired', 'error'].includes(normalized)) {
+                    return false;
+                }
+            }
+        }
+        return undefined;
+    }
+    function asRecord$1(value) {
         return value && typeof value === 'object' ? value : {};
     }
     function defaultNormalizeVerifyResponse(raw) {
-        const body = asRecord(raw);
-        const valid = Boolean(body.valid
-            ?? body.success
-            ?? body.active
-            ?? (typeof body.status === 'string' && body.status.toLowerCase() === 'active'));
+        const body = asRecord$1(raw);
+        const licenseStatus = readTextField(body, ['licenseStatus', 'license_status', 'status'])
+            || readTextField(asRecord$1(body.meta), ['license_status', 'status']);
+        const statusValid = typeof licenseStatus === 'string'
+            ? licenseStatus.toLowerCase() === 'active'
+            : undefined;
+        const valid = readBooleanField(body, ['valid', 'success', 'active'])
+            ?? statusValid
+            ?? false;
         const message = readTextField(body, ['message', 'error', 'detail']);
-        const nestedLicenseKey = asRecord(body.license_key);
-        const nestedMeta = asRecord(body.meta);
+        const nestedLicenseKey = asRecord$1(body.license_key);
+        const nestedMeta = asRecord$1(body.meta);
+        const nestedInstance = asRecord$1(body.instance);
+        const instanceId = readTextField(body, ['instanceId', 'instance_id'])
+            || readTextField(nestedInstance, ['id'])
+            || readTextField(nestedLicenseKey, ['instance_id']);
         const productId = readTextField(body, ['productId', 'product_id'])
             || readTextField(nestedMeta, ['product_id'])
             || readTextField(nestedLicenseKey, ['product_id']);
@@ -373,17 +788,37 @@
         const activationUsage = readNumberField(body, ['activationUsage', 'activation_usage'])
             ?? readNumberField(nestedMeta, ['activation_usage'])
             ?? readNumberField(nestedLicenseKey, ['activation_usage']);
+        const planTier = readTextField(body, ['planTier', 'tier', 'plan'])
+            || readTextField(nestedMeta, ['tier', 'plan']);
+        const licenseSource = readTextField(body, ['licenseSource', 'license_source', 'source'])
+            || readTextField(nestedMeta, ['license_source', 'source'])
+            || readTextField(nestedLicenseKey, ['license_source', 'source']);
+        const accessScope = readTextField(body, ['accessScope', 'access_scope', 'scope'])
+            || readTextField(nestedMeta, ['access_scope', 'scope'])
+            || readTextField(nestedLicenseKey, ['access_scope', 'scope']);
+        const expiresAt = readTextField(body, ['expiresAt', 'expires_at', 'expiration', 'expiration_date'])
+            || readTextField(nestedMeta, ['expires_at', 'expiration', 'expiration_date'])
+            || readTextField(nestedLicenseKey, ['expires_at', 'expiration', 'expiration_date']);
+        const errorCode = readTextField(body, ['errorCode', 'error_code', 'code'])
+            || readTextField(nestedMeta, ['error_code', 'code']);
         return {
             valid,
             message,
             productId,
             activationLimit,
             activationUsage,
+            instanceId,
+            planTier,
+            licenseStatus,
+            licenseSource,
+            accessScope,
+            expiresAt,
+            errorCode,
             raw,
         };
     }
     function defaultNormalizeDeactivateResponse(raw) {
-        const body = asRecord(raw);
+        const body = asRecord$1(raw);
         const success = Boolean(body.success
             ?? body.deactivated
             ?? body.valid
@@ -394,6 +829,14 @@
             raw,
         };
     }
+    class LicenseTransportHttpError extends Error {
+        constructor(status, body, message) {
+            super(message);
+            this.status = status;
+            this.body = body;
+            this.name = 'LicenseTransportHttpError';
+        }
+    }
     class FetchLicenseTransport {
         constructor(config) {
             this.config = config;
@@ -407,6 +850,15 @@
             const normalize = this.config.normalizeVerifyResponse ?? defaultNormalizeVerifyResponse;
             return normalize(raw);
         }
+        async validate(payload) {
+            const url = this.config.validateUrl || this.config.verifyUrl;
+            const body = this.config.buildValidateBody
+                ? this.config.buildValidateBody(payload)
+                : payload;
+            const raw = await this.postJson(url, body);
+            const normalize = this.config.normalizeVerifyResponse ?? defaultNormalizeVerifyResponse;
+            return normalize(raw);
+        }
         async deactivate(payload) {
             const url = this.config.deactivateUrl || this.config.verifyUrl;
             const body = this.config.buildDeactivateBody
@@ -436,8 +888,143 @@
                     signal: abortController?.signal,
                 });
                 if (!response.ok) {
-                    const errorText = await response.text();
-                    throw new Error(`HTTP ${response.status}: ${errorText || response.statusText}`);
+                    let errorBody;
+                    try {
+                        errorBody = await response.json();
+                    }
+                    catch {
+                        errorBody = await response.text();
+                    }
+                    const errorRecord = asRecord$1(errorBody);
+                    const errorMessage = readTextField(errorRecord, ['message', 'error', 'detail'])
+                        || (typeof errorBody === 'string' ? errorBody : '')
+                        || response.statusText;
+                    throw new LicenseTransportHttpError(response.status, errorBody, `HTTP ${response.status}: ${errorMessage}`);
+                }
+                return await response.json();
+            }
+            finally {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+            }
+        }
+    }
+
+    function asRecord(value) {
+        return value && typeof value === 'object' ? value : {};
+    }
+    function readText(raw, keys) {
+        const body = asRecord(raw);
+        for (const key of keys) {
+            const value = body[key];
+            if (typeof value === 'string' && value.trim() !== '') {
+                return value;
+            }
+        }
+        return '';
+    }
+    function readNumber(raw, keys) {
+        const body = asRecord(raw);
+        for (const key of keys) {
+            const value = body[key];
+            if (typeof value === 'number' && Number.isFinite(value)) {
+                return value;
+            }
+            if (typeof value === 'string' && value.trim() !== '') {
+                const numeric = Number(value);
+                if (Number.isFinite(numeric)) {
+                    return numeric;
+                }
+            }
+        }
+        return undefined;
+    }
+    function joinUrl(baseUrl, path) {
+        return `${baseUrl.replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}`;
+    }
+    class DesignbaseAccountAuthClient {
+        constructor(config) {
+            this.config = config;
+            if (!config.baseUrl.trim()) {
+                throw new Error('DesignbaseAccountAuthConfig.baseUrl is required.');
+            }
+            this.fetchFn = config.fetchFn ?? fetch;
+        }
+        async start(payload) {
+            const raw = await this.postJson(joinUrl(this.config.baseUrl, this.config.startPath || '/wp-json/custom/v1/figma/auth/start'), {
+                plugin_code: payload.pluginCode,
+                device_id: payload.deviceId,
+                return_url: payload.returnUrl || '',
+            });
+            return {
+                sessionId: readText(raw, ['session_id', 'sessionId']),
+                pollToken: readText(raw, ['poll_token', 'pollToken']),
+                authUrl: readText(raw, ['auth_url', 'authUrl']),
+                expiresIn: readNumber(raw, ['expires_in', 'expiresIn']) ?? 600,
+                pollInterval: readNumber(raw, ['poll_interval', 'pollInterval']) ?? 3,
+                raw,
+            };
+        }
+        async poll(sessionId, pollToken) {
+            const raw = await this.postJson(joinUrl(this.config.baseUrl, this.config.pollPath || '/wp-json/custom/v1/figma/auth/poll'), {
+                session_id: sessionId,
+                poll_token: pollToken,
+            });
+            const status = readText(raw, ['status']) || 'pending';
+            const allowed = Boolean(asRecord(raw).allowed || status === 'active');
+            const tokens = asRecord(asRecord(raw).tokens);
+            const actions = asRecord(asRecord(raw).actions);
+            return {
+                status,
+                allowed,
+                pluginCode: readText(raw, ['plugin_code', 'pluginCode']),
+                productId: readText(raw, ['product_id', 'productId']) || undefined,
+                planTier: readText(raw, ['plan_tier', 'planTier']) || undefined,
+                licenseKey: readText(raw, ['license_key', 'licenseKey']) || undefined,
+                accessToken: readText(tokens, ['access_token', 'accessToken']) || undefined,
+                refreshToken: readText(tokens, ['refresh_token', 'refreshToken']) || undefined,
+                expiresIn: readNumber(tokens, ['expires_in', 'expiresIn']),
+                message: readText(raw, ['message']) || undefined,
+                actions,
+                raw,
+            };
+        }
+        async saveTokens(result) {
+            if (!this.config.storage || !result.accessToken) {
+                return;
+            }
+            const prefix = this.config.storagePrefix || 'designbase-account-auth';
+            await Promise.all([
+                this.config.storage.set(`${prefix}:accessToken`, result.accessToken),
+                this.config.storage.set(`${prefix}:refreshToken`, result.refreshToken || ''),
+                this.config.storage.set(`${prefix}:expiresAt`, Date.now() + ((result.expiresIn || 1800) * 1000)),
+            ]);
+        }
+        async getAccessToken() {
+            if (!this.config.storage) {
+                return '';
+            }
+            const prefix = this.config.storagePrefix || 'designbase-account-auth';
+            const token = await this.config.storage.get(`${prefix}:accessToken`);
+            return typeof token === 'string' ? token : '';
+        }
+        async postJson(url, body) {
+            const timeoutMs = this.config.timeoutMs ?? 15000;
+            const abortController = typeof AbortController !== 'undefined' ? new AbortController() : undefined;
+            const timeoutId = abortController ? setTimeout(() => abortController.abort(), timeoutMs) : undefined;
+            try {
+                const response = await this.fetchFn(url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify(body),
+                    signal: abortController?.signal,
+                });
+                if (!response.ok) {
+                    const text = await response.text();
+                    throw new Error(`HTTP ${response.status}: ${text || response.statusText}`);
                 }
                 return await response.json();
             }
@@ -448,6 +1035,94 @@
             }
         }
     }
+    class DesignbaseAccountLicenseTransport {
+        constructor(config) {
+            this.config = config;
+            this.client = new DesignbaseAccountAuthClient(config);
+            this.fetchFn = config.fetchFn ?? fetch;
+        }
+        async verify(payload) {
+            return this.validate(payload);
+        }
+        async validate(payload) {
+            const token = await this.resolveAccessToken();
+            if (!token) {
+                return {
+                    valid: false,
+                    message: 'Designbase account access token is missing.',
+                    raw: { status: 'not_logged_in' },
+                };
+            }
+            const url = new URL(joinUrl(this.config.baseUrl, this.config.statusPath || '/wp-json/custom/v1/product/status'));
+            url.searchParams.set('plugin_code', payload.productId);
+            const raw = await this.getJson(url.toString(), token);
+            const status = readText(raw, ['status']);
+            const allowed = Boolean(asRecord(raw).allowed || status === 'active');
+            return {
+                valid: allowed,
+                message: readText(raw, ['message']) || undefined,
+                productId: readText(raw, ['plugin_code', 'pluginCode']) || payload.productId,
+                instanceId: payload.instanceId,
+                activationLimit: readNumber(raw, ['activation_limit', 'activationLimit']) ?? 999999,
+                activationUsage: readNumber(raw, ['activation_usage', 'activationUsage']) ?? 0,
+                planTier: readText(raw, ['plan_tier', 'planTier']) || (allowed ? 'PRO' : 'FREE'),
+                licenseKey: payload.licenseKey,
+                raw,
+            };
+        }
+        async deactivate(payload) {
+            const token = await this.resolveAccessToken();
+            if (!token) {
+                return { success: true, message: 'Already signed out.' };
+            }
+            const raw = await this.postJson(joinUrl(this.config.baseUrl, this.config.deactivatePath || '/wp-json/custom/v1/product/deactivate'), {
+                license_key: payload.licenseKey,
+                device_id: payload.instanceId || payload.instanceName,
+                plugin_code: payload.productId,
+            }, token);
+            const status = readText(raw, ['status']);
+            return {
+                success: Boolean(asRecord(raw).success || status === 'ok' || status === 'inactive'),
+                message: readText(raw, ['message']) || undefined,
+                raw,
+            };
+        }
+        async resolveAccessToken() {
+            if (this.config.getAccessToken) {
+                const token = await this.config.getAccessToken();
+                return typeof token === 'string' ? token : '';
+            }
+            return this.client.getAccessToken();
+        }
+        async getJson(url, token) {
+            const response = await this.fetchFn(url, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                throw new Error(`HTTP ${response.status}: ${text || response.statusText}`);
+            }
+            return response.json();
+        }
+        async postJson(url, body, token) {
+            const response = await this.fetchFn(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                throw new Error(`HTTP ${response.status}: ${text || response.statusText}`);
+            }
+            return response.json();
+        }
+    }
 
     class FigmaStorageAdapter {
         constructor(figma) {
@@ -478,25 +1153,38 @@
             }
         }
     }
-    const DEFAULT_MESSAGE_TYPES = {
+    const DEFAULT_LICENSE_MESSAGE_TYPES = {
         initialize: 'initialize',
         verifyLicense: 'verify-license',
         deactivateLicense: 'deactivate-license',
         updateStatus: 'update-plugin-status',
         verifyResult: 'license-verification-result',
         deactivateResult: 'license-deactivation-result',
+        checkFeatureAccess: 'check-feature-access',
+        consumeUsage: 'consume-usage',
+        featureAccessResult: 'feature-access-result',
+        usageConsumeResult: 'usage-consume-result',
     };
     class FigmaLicenseStatusManager {
         constructor(options) {
             this.options = options;
             this.messageTypes = {
-                ...DEFAULT_MESSAGE_TYPES,
+                ...DEFAULT_LICENSE_MESSAGE_TYPES,
                 ...(options.messageTypes || {}),
             };
             this.notifier = options.notifier;
         }
         async initialize() {
-            await this.postStatusUpdate();
+            if (!this.initializationPromise) {
+                this.initializationPromise = (async () => {
+                    const state = await this.options.core.initialize();
+                    await this.postStatusUpdate(state);
+                })().catch((error) => {
+                    this.initializationPromise = undefined;
+                    throw error;
+                });
+            }
+            await this.initializationPromise;
         }
         async handleMessage(pluginMessage) {
             if (!pluginMessage || typeof pluginMessage !== 'object') {
@@ -508,7 +1196,7 @@
                 return false;
             }
             if (type === this.messageTypes.initialize) {
-                await this.postStatusUpdate();
+                await this.initialize();
                 return true;
             }
             if (type === this.messageTypes.verifyLicense) {
@@ -520,6 +1208,22 @@
                 await this.handleDeactivateLicense();
                 return true;
             }
+            if (type === this.messageTypes.checkFeatureAccess) {
+                const featureKey = typeof message.featureKey === 'string' ? message.featureKey : undefined;
+                const amount = typeof message.amount === 'number' && Number.isFinite(message.amount) && message.amount > 0
+                    ? message.amount
+                    : 1;
+                await this.handleCheckFeatureAccess(featureKey, amount);
+                return true;
+            }
+            if (type === this.messageTypes.consumeUsage) {
+                const amount = typeof message.amount === 'number' && Number.isFinite(message.amount) && message.amount > 0
+                    ? message.amount
+                    : 1;
+                const featureKey = typeof message.featureKey === 'string' ? message.featureKey : undefined;
+                await this.handleConsumeUsage(amount, featureKey);
+                return true;
+            }
             return false;
         }
         bindToOnMessage(fallbackHandler) {
@@ -531,18 +1235,40 @@
                 }
             };
         }
+        /**
+         * Check a feature from main code using the same policy as the UI messages.
+         * This is the preferred guard for operations handled entirely in main.
+         */
+        async canUseFeature(featureKey, amount = 1) {
+            const state = await this.options.core.getStatus();
+            const safeAmount = Number.isFinite(amount) && amount > 0 ? amount : 1;
+            return this.options.core.resolveUsageAccess(state, featureKey, safeAmount);
+        }
+        /**
+         * Consume usage from main code and publish the refreshed status to the UI.
+         */
+        async consumeUsage(amount = 1, featureKey) {
+            const result = await this.options.core.consumeUsage(amount, featureKey);
+            await this.postStatusUpdate(result.state);
+            return result;
+        }
         async handleVerifyLicense(licenseKey) {
             try {
                 const state = await this.options.core.verifyLicense(licenseKey);
                 const access = this.options.core.resolveUsageAccess(state);
+                const summary = await this.options.core.getLicenseSummary();
                 this.postMessage({
                     type: this.messageTypes.verifyResult,
                     success: true,
                     message: '라이선스가 검증되었습니다.',
                     ...state,
-                    usageLimit: this.options.core.getUsageLimit(),
+                    ...summary,
+                    usageLimit: this.options.core.getUsageLimit(state),
                     canUseFeature: access.allowed,
                     remainingUsage: access.remaining,
+                    usageUsed: access.used,
+                    usageReset: access.reset,
+                    usageTier: access.tier,
                 });
                 await this.postStatusUpdate(state);
             }
@@ -555,20 +1281,26 @@
                     message: mappedError.message,
                     errorCode: mappedError.code,
                 });
+                await this.postStatusUpdate();
             }
         }
         async handleDeactivateLicense() {
             try {
                 const state = await this.options.core.deactivateLicense();
                 const access = this.options.core.resolveUsageAccess(state);
+                const summary = await this.options.core.getLicenseSummary();
                 this.postMessage({
                     type: this.messageTypes.deactivateResult,
                     success: true,
                     message: '라이선스가 비활성화되었습니다.',
                     ...state,
-                    usageLimit: this.options.core.getUsageLimit(),
+                    ...summary,
+                    usageLimit: this.options.core.getUsageLimit(state),
                     canUseFeature: access.allowed,
                     remainingUsage: access.remaining,
+                    usageUsed: access.used,
+                    usageReset: access.reset,
+                    usageTier: access.tier,
                 });
                 await this.postStatusUpdate(state);
             }
@@ -586,13 +1318,47 @@
         async postStatusUpdate(initialState) {
             const state = initialState ?? await this.options.core.getStatus();
             const access = this.options.core.resolveUsageAccess(state);
+            const summary = await this.options.core.getLicenseSummary();
             this.postMessage({
                 type: this.messageTypes.updateStatus,
                 ...state,
-                usageLimit: this.options.core.getUsageLimit(),
+                ...summary,
+                usageLimit: this.options.core.getUsageLimit(state),
                 canUseFeature: access.allowed,
                 remainingUsage: access.remaining,
+                usageUsed: access.used,
+                usageReset: access.reset,
+                usageTier: access.tier,
+                usageReason: access.reason,
+            });
+        }
+        async handleCheckFeatureAccess(featureKey, amount = 1) {
+            const state = await this.options.core.getStatus();
+            const access = this.options.core.resolveUsageAccess(state, featureKey, amount);
+            const summary = await this.options.core.getLicenseSummary();
+            this.postMessage({
+                type: this.messageTypes.featureAccessResult,
+                success: true,
+                featureKey,
+                amount,
+                ...summary,
+                ...access,
+            });
+        }
+        async handleConsumeUsage(amount, featureKey) {
+            const result = await this.options.core.consumeUsage(amount, featureKey);
+            const summary = await this.options.core.getLicenseSummary();
+            this.postMessage({
+                type: this.messageTypes.usageConsumeResult,
+                success: result.consumed,
+                featureKey,
+                amount,
+                consumed: result.consumed,
+                ...summary,
+                ...result.access,
+                usageCount: result.state.usageCount,
             });
+            await this.postStatusUpdate(result.state);
         }
         postMessage(message) {
             this.options.figma.ui.postMessage(message);
@@ -620,6 +1386,7 @@
         const notifier = options.notifier ?? new FigmaNotifierAdapter(figmaApi);
         const transport = options.transport ?? new FetchLicenseTransport({
             verifyUrl: options.config.endpoint,
+            validateUrl: options.config.validateEndpoint,
             deactivateUrl: options.config.deactivateEndpoint,
             headers: options.config.requestHeaders,
             timeoutMs: options.config.requestTimeoutMs,
@@ -639,12 +1406,16 @@
         });
     }
 
+    exports.DEFAULT_LICENSE_MESSAGE_TYPES = DEFAULT_LICENSE_MESSAGE_TYPES;
+    exports.DesignbaseAccountAuthClient = DesignbaseAccountAuthClient;
+    exports.DesignbaseAccountLicenseTransport = DesignbaseAccountLicenseTransport;
     exports.FetchLicenseTransport = FetchLicenseTransport;
     exports.FigmaLicenseStatusManager = FigmaLicenseStatusManager;
     exports.FigmaNotifierAdapter = FigmaNotifierAdapter;
     exports.FigmaStorageAdapter = FigmaStorageAdapter;
     exports.LicenseCore = LicenseCore;
     exports.LicenseCoreError = LicenseCoreError;
+    exports.LicenseTransportHttpError = LicenseTransportHttpError;
     exports.createFigmaLicenseStatusManager = createFigmaLicenseStatusManager;
     exports.defaultNormalizeDeactivateResponse = defaultNormalizeDeactivateResponse;
     exports.defaultNormalizeVerifyResponse = defaultNormalizeVerifyResponse;