@designbasekorea/figma-license-core 0.1.0 → 0.2.1

package/dist/index.js

@@ -4,6 +4,9 @@ exports.LicenseErrorCode = void 0;
 (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";
@@ -27,10 +30,18 @@ function asText(input) {
     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 {
@@ -48,13 +59,32 @@ function inferCode(text) {
         || 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')
@@ -75,7 +105,9 @@ function mapLicenseError(error, fallbackMessage = '라이선스 처리 중 알
     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) {
@@ -87,10 +119,19 @@ function isActivationLimitReached(activationLimit, activationUsage) {
 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;
@@ -109,6 +150,31 @@ function toNonNegativeNumber(value, fallback = 0) {
 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;
@@ -118,6 +184,59 @@ function toPaymentStatus(value) {
 function normalizeProductId(productId) {
     return productId.trim().toLowerCase();
 }
+function normalizeTier(tier) {
+    return tier.trim() || 'FREE';
+}
+function normalizeUsageReset(reset) {
+    if (reset === 'daily' || 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}`;
+    }
+    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;
@@ -131,14 +250,117 @@ class LicenseCore {
         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();
@@ -146,18 +368,27 @@ class LicenseCore {
             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 {
@@ -171,7 +402,7 @@ class LicenseCore {
             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)) {
@@ -182,21 +413,32 @@ class LicenseCore {
         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;
         }
@@ -204,6 +446,7 @@ class LicenseCore {
             licenseKey: current.licenseKey,
             productId: this.config.productId,
             instanceName: this.config.instanceName,
+            instanceId: current.instanceId,
         };
         if (!this.config.masterCode || current.licenseKey !== this.config.masterCode) {
             try {
@@ -216,24 +459,19 @@ class LicenseCore {
                 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);
+        if (increasedAmount === 0) {
+            return current;
+        }
         const nextState = {
             ...current,
             usageCount: current.usageCount + increasedAmount,
@@ -241,64 +479,186 @@ class LicenseCore {
         await this.persistState(nextState);
         return nextState;
     }
-    async canUseFeature() {
-        const state = await this.loadState();
-        return this.resolveUsageAccess(state);
+    async canUseFeature(featureKey) {
+        const state = await this.getStatus();
+        return this.resolveUsageAccess(state, featureKey);
     }
-    resolveUsageAccess(state) {
-        if (state.paymentStatus === 'PAID') {
+    async consumeUsage(amount = 1, featureKey) {
+        const state = await this.getStatus();
+        const access = this.resolveUsageAccess(state, featureKey);
+        if (!access.allowed || amount <= 0) {
+            return { state, access };
+        }
+        const updatedState = await this.incrementUsage(amount);
+        const updatedAccess = this.resolveUsageAccess(updatedState, featureKey);
+        return {
+            state: updatedState,
+            access: updatedAccess,
+        };
+    }
+    resolveUsageAccess(state, featureKey) {
+        const tier = this.resolveTier(state);
+        const usagePolicy = this.getUsagePolicy(tier);
+        const featureAllowed = this.isFeatureAllowed(tier, featureKey);
+        const isLicensed = this.isLicenseRegisteredState(state);
+        const used = state.usageCount;
+        if (usagePolicy.limit === 'unlimited') {
             return {
-                allowed: true,
+                allowed: featureAllowed,
                 remaining: Number.POSITIVE_INFINITY,
+                used,
+                limit: 'unlimited',
+                reset: usagePolicy.reset,
+                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 > 0;
+        const allowed = featureAllowed && usageAllowed;
         return {
-            allowed: remaining > 0,
+            allowed,
             remaining,
+            used,
+            limit: usagePolicy.limit,
+            reset: usagePolicy.reset,
+            tier,
+            hasLicenseKey: Boolean(state.licenseKey),
+            isLicenseRegistered: isLicensed,
+            featureAllowed,
+            featureKey,
+            reason: featureAllowed ? (usageAllowed ? undefined : 'USAGE_LIMIT_REACHED') : 'FEATURE_NOT_ALLOWED',
         };
     }
     getUsageLimit() {
-        return this.usageLimit;
+        const freePolicy = this.getUsagePolicy(this.policy.freeTier);
+        return freePolicy.limit === 'unlimited' ? Number.POSITIVE_INFINITY : freePolicy.limit;
     }
     getStoragePrefix() {
         return this.storagePrefix;
     }
+    resolveTier(state) {
+        const storedTier = normalizeTier(state.planTier || '');
+        if (storedTier) {
+            return storedTier;
+        }
+        return state.paymentStatus === 'PAID' ? this.policy.paidTier : this.policy.freeTier;
+    }
+    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) {
@@ -348,18 +708,47 @@ function readNumberField(raw, keys) {
     }
     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']);
@@ -369,17 +758,37 @@ function defaultNormalizeVerifyResponse(raw) {
     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
@@ -390,6 +799,14 @@ function defaultNormalizeDeactivateResponse(raw) {
         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;
@@ -403,6 +820,15 @@ class FetchLicenseTransport {
         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
@@ -432,8 +858,143 @@ class FetchLicenseTransport {
                 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();
         }
@@ -444,6 +1005,94 @@ class FetchLicenseTransport {
         }
     }
 }
+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) {
@@ -485,6 +1134,8 @@ const DEFAULT_MESSAGE_TYPES = {
 class FigmaLicenseStatusManager {
     constructor(options) {
         this.options = options;
+        this.featureAccessMessageType = 'feature-access-result';
+        this.consumeUsageMessageType = 'usage-consume-result';
         this.messageTypes = {
             ...DEFAULT_MESSAGE_TYPES,
             ...(options.messageTypes || {}),
@@ -492,7 +1143,16 @@ class FigmaLicenseStatusManager {
         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') {
@@ -504,7 +1164,7 @@ class FigmaLicenseStatusManager {
             return false;
         }
         if (type === this.messageTypes.initialize) {
-            await this.postStatusUpdate();
+            await this.initialize();
             return true;
         }
         if (type === this.messageTypes.verifyLicense) {
@@ -516,6 +1176,17 @@ class FigmaLicenseStatusManager {
             await this.handleDeactivateLicense();
             return true;
         }
+        if (type === 'check-feature-access') {
+            const featureKey = typeof message.featureKey === 'string' ? message.featureKey : undefined;
+            await this.handleCheckFeatureAccess(featureKey);
+            return true;
+        }
+        if (type === 'consume-usage') {
+            const amount = typeof message.amount === 'number' ? message.amount : 1;
+            const featureKey = typeof message.featureKey === 'string' ? message.featureKey : undefined;
+            await this.handleConsumeUsage(amount, featureKey);
+            return true;
+        }
         return false;
     }
     bindToOnMessage(fallbackHandler) {
@@ -531,14 +1202,19 @@ class FigmaLicenseStatusManager {
         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,
+                ...summary,
                 usageLimit: this.options.core.getUsageLimit(),
                 canUseFeature: access.allowed,
                 remainingUsage: access.remaining,
+                usageUsed: access.used,
+                usageReset: access.reset,
+                usageTier: access.tier,
             });
             await this.postStatusUpdate(state);
         }
@@ -551,20 +1227,26 @@ class FigmaLicenseStatusManager {
                 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,
+                ...summary,
                 usageLimit: this.options.core.getUsageLimit(),
                 canUseFeature: access.allowed,
                 remainingUsage: access.remaining,
+                usageUsed: access.used,
+                usageReset: access.reset,
+                usageTier: access.tier,
             });
             await this.postStatusUpdate(state);
         }
@@ -582,13 +1264,45 @@ class FigmaLicenseStatusManager {
     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,
+            ...summary,
             usageLimit: this.options.core.getUsageLimit(),
             canUseFeature: access.allowed,
             remainingUsage: access.remaining,
+            usageUsed: access.used,
+            usageReset: access.reset,
+            usageTier: access.tier,
+            usageReason: access.reason,
+        });
+    }
+    async handleCheckFeatureAccess(featureKey) {
+        const state = await this.options.core.getStatus();
+        const access = this.options.core.resolveUsageAccess(state, featureKey);
+        const summary = await this.options.core.getLicenseSummary();
+        this.postMessage({
+            type: this.featureAccessMessageType,
+            success: true,
+            featureKey,
+            ...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.consumeUsageMessageType,
+            success: result.access.allowed,
+            featureKey,
+            amount,
+            ...summary,
+            ...result.access,
+            usageCount: result.state.usageCount,
         });
+        await this.postStatusUpdate(result.state);
     }
     postMessage(message) {
         this.options.figma.ui.postMessage(message);
@@ -616,6 +1330,7 @@ function createFigmaLicenseStatusManager(options) {
     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,
@@ -635,12 +1350,15 @@ function createFigmaLicenseStatusManager(options) {
     });
 }
 
+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;