@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/license/certificate.d.ts

@@ -0,0 +1,48 @@
+import type { Failure } from './failure';
+import type { LicenseProduct } from './types';
+import type { LicenseDeployment } from './deployment';
+export interface IssuanceClaims {
+    readonly iss: unknown;
+    readonly aud: unknown;
+    readonly env: unknown;
+}
+export interface CertificateGrant {
+    readonly product: LicenseProduct;
+    readonly features: readonly string[];
+    readonly allFeatures: boolean;
+    readonly validFrom: string;
+    readonly paidThrough: string;
+    readonly updatesUntil: string;
+    readonly validFromMs: number;
+    readonly paidThroughMs: number;
+    readonly updatesUntilMs: number;
+}
+export interface CertificateClaims extends IssuanceClaims {
+    readonly deployment?: LicenseDeployment;
+    readonly policy: string;
+    readonly organizationRef: string;
+    readonly licenseFamilyId: string;
+    readonly certificateId: string;
+    readonly revision: number;
+    readonly issuedAt: string;
+    readonly grants: readonly CertificateGrant[];
+}
+export interface RevocationClaims extends IssuanceClaims {
+    readonly issuedAt: string;
+    readonly sequence: number;
+    readonly revokedCertificateIds: ReadonlySet<string>;
+}
+export interface LicenseInput {
+    readonly ok: true;
+    readonly certificate: string;
+    readonly revocations: string | null;
+}
+export declare function validateCertificateClaims(claims: Record<string, unknown>): {
+    ok: true;
+    claims: CertificateClaims;
+} | Failure;
+export declare function validateRevocationClaims(claims: Record<string, unknown>): {
+    ok: true;
+    claims: RevocationClaims;
+} | Failure;
+export declare function parseLicenseInput(input: unknown): LicenseInput | Failure;

package/dist/license/certificate.js

@@ -0,0 +1 @@
+import{ALL_FEATURES,CERTIFICATE_ID_PATTERN,CERTIFICATE_TYPE,FEATURE_ID_PATTERN,FORMAT_SCHEMA,GRANT_USE,LICENSE_FAMILY_ID_PATTERN,LICENSE_FILE_TYPE,LICENSE_PRODUCTS,MAX_FEATURE_ID_LENGTH,MAX_FEATURES,MAX_GRANTS,MAX_LICENSE_FILE_LENGTH,ORGANIZATION_ID_PATTERN,REVOCATION_REASONS,REVOCATIONS_TYPE,SUPPORTED_POLICIES}from"./constants.js";import{failure,isFailure}from"./failure.js";import{findMissingKey,findUnknownKey,isPlainObject,quoteName}from"./json.js";import{parseUtcTimestamp}from"./timestamp.js";import{parseDeployment}from"./deployment.js";const CERTIFICATE_MEMBERS=["typ","schema","policy","iss","aud","env","organizationRef","licenseFamilyId","certificateId","revision","issuedAt","grants"];const GRANT_MEMBERS=["product","features","use","validFrom","paidThrough","updatesUntil"];const REVOCATIONS_MEMBERS=["typ","schema","iss","aud","env","issuedAt","sequence","revoked"];const REVOKED_ENTRY_MEMBERS=["certificateId","revokedAt","reason"];const LICENSE_FILE_MEMBERS=["type","schema","certificate","revocations"];const LICENSE_FILE_REQUIRED=["type","schema","certificate"];export function validateCertificateClaims(claims){if(claims.typ!==CERTIFICATE_TYPE)return failure("schema-mismatch",`Payload typ must be "${CERTIFICATE_TYPE}".`);if(claims.schema!==FORMAT_SCHEMA)return failure("schema-mismatch",`Unsupported certificate schema; expected ${FORMAT_SCHEMA}.`);const hasDeployment=claims.policy==="2026-10"||claims.policy==="2026-10-annual";const memberNames=hasDeployment?[...CERTIFICATE_MEMBERS,"deployment"]:CERTIFICATE_MEMBERS;const members=checkMembers(claims,memberNames,memberNames,"certificate");if(members)return members;if(typeof claims.policy!=="string"||!SUPPORTED_POLICIES.includes(claims.policy)){return failure("schema-mismatch","Unsupported certificate policy version.")}if(!matches(claims.organizationRef,ORGANIZATION_ID_PATTERN))return invalid("organizationRef");let deployment;if(hasDeployment){const parsedDeployment=parseDeployment(claims.deployment);if(isFailure(parsedDeployment))return parsedDeployment;deployment=parsedDeployment}if(!matches(claims.licenseFamilyId,LICENSE_FAMILY_ID_PATTERN))return invalid("licenseFamilyId");if(!matches(claims.certificateId,CERTIFICATE_ID_PATTERN))return invalid("certificateId");if(!isPositiveSafeInteger(claims.revision))return invalid("revision");if(parseUtcTimestamp(claims.issuedAt)===null)return invalid("issuedAt");const grants=claims.grants;if(!Array.isArray(grants)||grants.length===0||grants.length>MAX_GRANTS){return failure("invalid-field",`grants must hold 1–${MAX_GRANTS} entries.`)}const parsedGrants=[];for(let index=0;index<grants.length;index+=1){const grant=validateGrant(grants[index],index);if(isFailure(grant))return grant;parsedGrants.push(grant.grant)}return{ok:true,claims:{iss:claims.iss,aud:claims.aud,env:claims.env,policy:claims.policy,organizationRef:claims.organizationRef,licenseFamilyId:claims.licenseFamilyId,certificateId:claims.certificateId,revision:claims.revision,issuedAt:claims.issuedAt,grants:parsedGrants,...deployment?{deployment}:{}}}}function validateGrant(value,index){const label=`grants[${index}]`;if(!isPlainObject(value))return failure("invalid-field",`${label} must be an object.`);const members=checkMembers(value,GRANT_MEMBERS,GRANT_MEMBERS,label);if(members)return members;const product=value.product;if(typeof product!=="string"||!LICENSE_PRODUCTS.includes(product)){return invalid(`${label}.product`)}if(value.use!==GRANT_USE)return invalid(`${label}.use`);const features=validateFeatures(value.features,product,label);if(isFailure(features))return features;const validFromMs=parseUtcTimestamp(value.validFrom);const paidThroughMs=parseUtcTimestamp(value.paidThrough);const updatesUntilMs=parseUtcTimestamp(value.updatesUntil);if(validFromMs===null)return invalid(`${label}.validFrom`);if(paidThroughMs===null)return invalid(`${label}.paidThrough`);if(updatesUntilMs===null)return invalid(`${label}.updatesUntil`);if(!(validFromMs<paidThroughMs))return failure("invalid-field",`${label}: validFrom must be before paidThrough.`);if(!(validFromMs<=updatesUntilMs))return failure("invalid-field",`${label}: validFrom must not be after updatesUntil.`);if(updatesUntilMs>paidThroughMs)return failure("invalid-field",`${label}: updatesUntil must not be after paidThrough.`);return{ok:true,grant:{product,features:features.features,allFeatures:features.features[0]===ALL_FEATURES,validFrom:value.validFrom,paidThrough:value.paidThrough,updatesUntil:value.updatesUntil,validFromMs,paidThroughMs,updatesUntilMs}}}function validateFeatures(value,product,label){if(!Array.isArray(value)||value.length===0||value.length>MAX_FEATURES){return failure("invalid-field",`${label}.features must hold 1–${MAX_FEATURES} entries.`)}if(value.includes(ALL_FEATURES)){return value.length===1?{ok:true,features:Object.freeze([ALL_FEATURES])}:failure("invalid-field",`${label}.features: "*" cannot be combined with feature IDs.`)}const seen=new Set;for(const feature of value){if(typeof feature!=="string"||feature.length>MAX_FEATURE_ID_LENGTH||!FEATURE_ID_PATTERN.test(feature)){return invalid(`${label}.features`)}if(!feature.startsWith(`${product}.`)){return failure("invalid-field",`${label}.features: "${feature}" does not belong to product "${product}".`)}if(seen.has(feature))return failure("invalid-field",`${label}.features: duplicate "${feature}".`);seen.add(feature)}return{ok:true,features:Object.freeze([...seen])}}export function validateRevocationClaims(claims){if(claims.typ!==REVOCATIONS_TYPE)return failure("schema-mismatch",`Payload typ must be "${REVOCATIONS_TYPE}".`);if(claims.schema!==FORMAT_SCHEMA)return failure("schema-mismatch",`Unsupported revocation schema; expected ${FORMAT_SCHEMA}.`);const members=checkMembers(claims,REVOCATIONS_MEMBERS,REVOCATIONS_MEMBERS,"revocation list");if(members)return members;if(parseUtcTimestamp(claims.issuedAt)===null)return invalid("issuedAt");const sequence=claims.sequence;if(typeof sequence!=="number"||!Number.isSafeInteger(sequence)||sequence<0)return invalid("sequence");const revoked=claims.revoked;if(!Array.isArray(revoked))return failure("invalid-field","revoked must be an array.");const ids=new Set;for(let index=0;index<revoked.length;index+=1){const entry=revoked[index];const label=`revoked[${index}]`;if(!isPlainObject(entry))return failure("invalid-field",`${label} must be an object.`);const entryMembers=checkMembers(entry,REVOKED_ENTRY_MEMBERS,REVOKED_ENTRY_MEMBERS,label);if(entryMembers)return entryMembers;if(!matches(entry.certificateId,CERTIFICATE_ID_PATTERN))return invalid(`${label}.certificateId`);if(parseUtcTimestamp(entry.revokedAt)===null)return invalid(`${label}.revokedAt`);if(typeof entry.reason!=="string"||!REVOCATION_REASONS.includes(entry.reason))return invalid(`${label}.reason`);ids.add(entry.certificateId)}return{ok:true,claims:{iss:claims.iss,aud:claims.aud,env:claims.env,issuedAt:claims.issuedAt,sequence,revokedCertificateIds:ids}}}export function parseLicenseInput(input){if(typeof input==="string"){const text=input.replace(/^/,"").trim();if(text.length>MAX_LICENSE_FILE_LENGTH)return failure("too-large",`License input exceeds ${MAX_LICENSE_FILE_LENGTH} characters.`);if(text.length===0)return failure("malformed","License input is empty.");if(!text.startsWith("{"))return{ok:true,certificate:text,revocations:null};let parsed;try{parsed=JSON.parse(text)}catch{return failure("malformed","License file is not valid JSON.")}return validateLicenseFile(parsed)}return validateLicenseFile(input)}function validateLicenseFile(value){if(!isPlainObject(value))return failure("malformed","License input must be a JWS string or a license file.");if(value.type!==LICENSE_FILE_TYPE)return failure("schema-mismatch",`License file type must be "${LICENSE_FILE_TYPE}".`);if(value.schema!==FORMAT_SCHEMA)return failure("schema-mismatch",`Unsupported license file schema; expected ${FORMAT_SCHEMA}.`);const members=checkMembers(value,LICENSE_FILE_MEMBERS,LICENSE_FILE_REQUIRED,"license file");if(members)return members;if(typeof value.certificate!=="string"||value.certificate.length===0)return invalid("certificate");const revocations=value.revocations;if(revocations!==void 0&&(typeof revocations!=="string"||revocations.length===0)){return invalid("revocations")}return{ok:true,certificate:value.certificate,revocations:typeof revocations==="string"?revocations:null}}function checkMembers(value,allowed,required,label){const unknown=findUnknownKey(value,allowed);if(unknown!==null)return failure("invalid-field",`Unknown ${label} member ${quoteName(unknown)}.`);const missing=findMissingKey(value,required);if(missing!==null)return failure("invalid-field",`Missing ${label} member "${missing}".`);return null}function invalid(field){return failure("invalid-field",`Invalid value for "${field}".`)}function matches(value,pattern){return typeof value==="string"&&pattern.test(value)}function isPositiveSafeInteger(value){return typeof value==="number"&&Number.isSafeInteger(value)&&value>=1}

package/dist/license/constants.d.ts

@@ -0,0 +1,38 @@
+export { FEATURE_ID_PATTERN, LICENSE_PRODUCTS, WARNINGS_SYMBOL_KEY } from './diagnostic-constants';
+export declare const REGISTRY_SYMBOL_KEY = "syidax.license.registry/v1";
+export declare const LICENSE_ENVIRONMENTS: readonly [
+    "production",
+    "test"
+];
+export declare const JWS_ALGORITHM = "ES256";
+export declare const JWS_TYPE = "syidax-license+jws";
+export declare const JWS_HEADER_MEMBERS: readonly string[];
+export declare const KEY_LOCATION_HEADER_MEMBERS: readonly string[];
+export declare const CERTIFICATE_TYPE = "syidax.license.certificate";
+export declare const REVOCATIONS_TYPE = "syidax.license.revocations";
+export declare const LICENSE_FILE_TYPE = "syidax.license.file";
+export declare const FORMAT_SCHEMA = 1;
+export declare const SUPPORTED_POLICIES: readonly string[];
+export declare const ISSUER = "syidax-license-service";
+export declare const AUDIENCE = "syidax-runtime";
+export declare const GRANT_USE = "commercial";
+export declare const MAX_CERTIFICATE_TOKEN_LENGTH: number;
+export declare const MAX_REVOCATIONS_TOKEN_LENGTH: number;
+export declare const MAX_LICENSE_FILE_LENGTH: number;
+export declare const MAX_GRANTS = 32;
+export declare const MAX_FEATURES = 64;
+export declare const MAX_KID_LENGTH = 128;
+export declare const MAX_FEATURE_ID_LENGTH = 128;
+export declare const P256_COORDINATE_BYTES = 32;
+export declare const ES256_SIGNATURE_BYTES = 64;
+export declare const ORGANIZATION_ID_PATTERN: RegExp;
+export declare const LICENSE_FAMILY_ID_PATTERN: RegExp;
+export declare const CERTIFICATE_ID_PATTERN: RegExp;
+export declare const TIMESTAMP_PATTERN: RegExp;
+export declare const KEY_ID_PATTERN: RegExp;
+export declare const ALL_FEATURES = "*";
+export declare const REVOCATION_REASONS: readonly string[];
+export declare const DECLARATIVE_SCRIPT_TYPE = "application/syidax-license+json";
+export declare const DECLARATIVE_META_NAME = "syidax-license";
+export declare const MAX_TIMER_DELAY_MS: number;
+export declare const DEFAULT_FETCH_TIMEOUT_MS = 15000;

package/dist/license/constants.js

@@ -0,0 +1 @@
+export{FEATURE_ID_PATTERN,LICENSE_PRODUCTS,WARNINGS_SYMBOL_KEY}from"./diagnostic-constants.js";export const REGISTRY_SYMBOL_KEY="syidax.license.registry/v1";export const LICENSE_ENVIRONMENTS=["production","test"];export const JWS_ALGORITHM="ES256";export const JWS_TYPE="syidax-license+jws";export const JWS_HEADER_MEMBERS=["alg","kid","typ"];export const KEY_LOCATION_HEADER_MEMBERS=["jku","jwk","x5u","x5c","x5t","x5t#S256"];export const CERTIFICATE_TYPE="syidax.license.certificate";export const REVOCATIONS_TYPE="syidax.license.revocations";export const LICENSE_FILE_TYPE="syidax.license.file";export const FORMAT_SCHEMA=1;export const SUPPORTED_POLICIES=["2026-09","2026-10","2026-09-annual","2026-10-annual"];export const ISSUER="syidax-license-service";export const AUDIENCE="syidax-runtime";export const GRANT_USE="commercial";export const MAX_CERTIFICATE_TOKEN_LENGTH=16*1024;export const MAX_REVOCATIONS_TOKEN_LENGTH=64*1024;export const MAX_LICENSE_FILE_LENGTH=96*1024;export const MAX_GRANTS=32;export const MAX_FEATURES=64;export const MAX_KID_LENGTH=128;export const MAX_FEATURE_ID_LENGTH=128;export const P256_COORDINATE_BYTES=32;export const ES256_SIGNATURE_BYTES=64;export const ORGANIZATION_ID_PATTERN=/^org_[A-Za-z0-9_-]{6,64}$/;export const LICENSE_FAMILY_ID_PATTERN=/^lf_[A-Za-z0-9_-]{6,64}$/;export const CERTIFICATE_ID_PATTERN=/^cert_[A-Za-z0-9_-]{6,64}$/;export const TIMESTAMP_PATTERN=/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{3}))?Z$/;export const KEY_ID_PATTERN=/^syx-(production|test)-\d{6}-\d{1,6}$/;export const ALL_FEATURES="*";export const REVOCATION_REASONS=["refund","dispute","reissue","key-compromise","other"];export const DECLARATIVE_SCRIPT_TYPE="application/syidax-license+json";export const DECLARATIVE_META_NAME="syidax-license";export const MAX_TIMER_DELAY_MS=2**31-1;export const DEFAULT_FETCH_TIMEOUT_MS=15e3;

package/dist/license/context.d.ts

@@ -0,0 +1,6 @@
+import type { ContextRecord, LicenseRegistry } from './registry';
+import type { LicenseContext, LicenseContextOptions } from './types';
+export declare function createContext(registry: LicenseRegistry, options?: LicenseContextOptions): LicenseContext;
+export declare function documentRecord(registry: LicenseRegistry, document: object): ContextRecord;
+export declare function bindContext(registry: LicenseRegistry, root: unknown, context: LicenseContext): () => void;
+export declare function resolveRecordForElement(registry: LicenseRegistry, element: unknown): ContextRecord;

package/dist/license/context.js

@@ -0,0 +1 @@
+import{ORGANIZATION_ID_PATTERN}from"./constants.js";import{contextRequiredError}from"./failure.js";import{createContextRecord,lookupRecord}from"./registry.js";const DOCUMENT_NODE=9;const DOCUMENT_FRAGMENT_NODE=11;const MAX_CONTEXT_NAME_LENGTH=200;export function createContext(registry,options={}){if(typeof options!=="object"||options===null)throw new TypeError("License context options must be an object.");const{name,organizationRef,now}=options;if(name!==void 0&&(typeof name!=="string"||name.length===0||name.length>MAX_CONTEXT_NAME_LENGTH)){throw new TypeError(`License context name must be a string of 1–${MAX_CONTEXT_NAME_LENGTH} characters.`)}if(organizationRef!==void 0&&(typeof organizationRef!=="string"||!ORGANIZATION_ID_PATTERN.test(organizationRef))){throw new TypeError('organizationRef must look like "org_…".')}if(now!==void 0&&typeof now!=="function")throw new TypeError("now must be a function returning epoch milliseconds.");return createContextRecord(registry,{name,organizationRef,now}).handle}export function documentRecord(registry,document){const existing=registry.documentContexts.get(document);if(existing)return lookupRecord(registry,existing);const record=createContextRecord(registry,{name:"document",document});registry.documentContexts.set(document,record.handle);return record}export function bindContext(registry,root,context){if(typeof root!=="object"||root===null)throw new TypeError("bindLicenseContext needs a DOM node as root.");lookupRecord(registry,context);registry.bindings.set(root,context);return()=>{if(registry.bindings.get(root)===context)registry.bindings.delete(root)}}export function resolveRecordForElement(registry,element){if(typeof element!=="object"||element===null)throw new TypeError("resolveLicenseContext needs an element.");let node=element;while(node){const bound=registry.bindings.get(node);if(bound)return lookupRecord(registry,bound);if(node.nodeType===DOCUMENT_NODE)return documentRecord(registry,node);node=node.parentNode??(node.nodeType===DOCUMENT_FRAGMENT_NODE?node.host:null)}const owner=element.ownerDocument;if(owner)return documentRecord(registry,owner);throw contextRequiredError()}

package/dist/license/deployment.d.ts

@@ -0,0 +1,9 @@
+import type { Failure } from './failure';
+export declare const WEBSITE_DEMO_BUILD = false;
+export interface LicenseDeployment {
+    readonly kind: 'customer' | 'demo';
+    readonly origins: readonly string[];
+    readonly allowLocalhost: boolean;
+}
+export declare function parseDeployment(value: unknown): LicenseDeployment | Failure;
+export declare function deploymentFailure(deployment: LicenseDeployment | undefined, origin: string | undefined, demoBuild?: boolean): Failure | null;

package/dist/license/deployment.js

@@ -0,0 +1 @@
+import{failure}from"./failure.js";export const WEBSITE_DEMO_BUILD=false;export function parseDeployment(value){if(!value||typeof value!=="object"||Array.isArray(value))return failure("invalid-field","deployment is required.");const item=value;if(Object.keys(item).sort().join(",")!=="allowLocalhost,kind,origins"||!["customer","demo"].includes(String(item.kind))||typeof item.allowLocalhost!=="boolean"||!Array.isArray(item.origins)||item.origins.length>20||item.origins.length===0&&(item.kind!=="customer"||!item.allowLocalhost)){return failure("invalid-field","Invalid deployment restrictions.")}for(const origin of item.origins){try{const url=new URL(origin);if(typeof origin!=="string"||url.origin!==origin||url.protocol!=="https:"||url.username||url.password||url.hostname.includes("*"))throw new Error}catch{return failure("invalid-field","Origins must be exact HTTPS origins, without paths or wildcards.")}}if(new Set(item.origins).size!==item.origins.length||item.kind==="demo"&&item.allowLocalhost)return failure("invalid-field","Invalid deployment restrictions.");return Object.freeze({kind:item.kind,origins:Object.freeze([...item.origins]),allowLocalhost:item.allowLocalhost})}export function deploymentFailure(deployment,origin,demoBuild=WEBSITE_DEMO_BUILD){if(!deployment)return null;if(deployment.kind==="demo"&&!demoBuild)return failure("wrong-audience","Website demo certificates cannot activate customer packages.");if(!origin||origin==="null")return failure("cross-origin-url","A licensed page origin is required.");let url;try{url=new URL(origin)}catch{return failure("cross-origin-url","Invalid page origin.")}const local=["localhost","127.0.0.1","[::1]"].includes(url.hostname)||url.hostname.endsWith(".localhost");if(deployment.kind==="customer"&&deployment.allowLocalhost&&local&&["http:","https:"].includes(url.protocol))return null;return deployment.origins.includes(url.origin)?null:failure("cross-origin-url","This origin is not licensed.")}

package/dist/license/diagnostic-constants.d.ts

@@ -0,0 +1,7 @@
+export declare const WARNINGS_SYMBOL_KEY = "syidax.license.warnings/v1";
+export declare const LICENSE_PRODUCTS: readonly [
+    "core",
+    "chart",
+    "grid"
+];
+export declare const FEATURE_ID_PATTERN: RegExp;

package/dist/license/diagnostic-constants.js

@@ -0,0 +1 @@
+export const WARNINGS_SYMBOL_KEY="syidax.license.warnings/v1";export const LICENSE_PRODUCTS=["core","chart","grid"];export const FEATURE_ID_PATTERN=/^(core|chart|grid)\.[a-z0-9]+(?:-[a-z0-9]+)*(?:\.[a-z0-9]+(?:-[a-z0-9]+)*)*$/;

package/dist/license/discovery.d.ts

@@ -0,0 +1,10 @@
+export type DeclarativeLicense = {
+    readonly kind: 'inline';
+    readonly text: string;
+} | {
+    readonly kind: 'url';
+    readonly url: string;
+};
+export declare function findDeclarativeLicense(document: object): DeclarativeLicense | null;
+export declare function isDocumentLoading(document: object): boolean;
+export declare function whenDocumentParsed(document: object): Promise<void>;

package/dist/license/discovery.js

@@ -0,0 +1 @@
+import{DECLARATIVE_META_NAME,DECLARATIVE_SCRIPT_TYPE}from"./constants.js";export function findDeclarativeLicense(document){const query=document.querySelector;if(typeof query!=="function")return null;const script=query.call(document,`script[type="${DECLARATIVE_SCRIPT_TYPE}"]`);const inline=script?.textContent;if(typeof inline==="string"&&inline.trim().length>0)return{kind:"inline",text:inline};const meta=query.call(document,`meta[name="${DECLARATIVE_META_NAME}"]`);const url=meta?.getAttribute?.("content");if(typeof url==="string"&&url.trim().length>0)return{kind:"url",url:url.trim()};return null}export function isDocumentLoading(document){const target=document;return target.readyState==="loading"&&typeof target.addEventListener==="function"}export function whenDocumentParsed(document){if(!isDocumentLoading(document))return Promise.resolve();return new Promise(resolve=>document.addEventListener?.("DOMContentLoaded",()=>resolve(),{once:true}))}

package/dist/license/errors.d.ts

@@ -0,0 +1,47 @@
+import type { EntitlementCode, EntitlementState, LicenseProduct } from './types';
+export declare const LICENSE_ERROR_NAME = "SyidaxLicenseError";
+export declare const LICENSE_STATE_CHANGED_EVENT = "licenseStateChanged";
+export declare const LICENSE_FEATURE_REFUSED_EVENT = "licenseFeatureRefused";
+export declare const LICENSE_ATTR: Readonly<{
+    state: 'data-license-state';
+    feature: 'data-license-feature';
+    frozen: 'data-license-frozen';
+    refused: 'data-license-refused';
+}>;
+export declare const LICENSE_WARNING_PREFIX = "[Syidax] ";
+export declare const MAX_LICENSE_WARNING_KEYS = 256;
+export type LicenseDiagnosticCode = 'license-required' | 'license-pending' | 'module-missing' | 'load-failed' | 'engine-unsupported' | 'disposed' | 'stale';
+export type LicenseEventType = typeof LICENSE_STATE_CHANGED_EVENT | typeof LICENSE_FEATURE_REFUSED_EVENT;
+export interface LicenseErrorInit {
+    readonly code: LicenseDiagnosticCode;
+    readonly product: LicenseProduct;
+    readonly feature: string;
+    readonly state: EntitlementState;
+    readonly tag?: string;
+    readonly method?: string;
+    readonly reason?: unknown;
+    readonly message?: string;
+}
+export interface LicenseEventDetail {
+    readonly product: LicenseProduct;
+    readonly feature: string;
+    readonly state: EntitlementState;
+    readonly code: LicenseDiagnosticCode | EntitlementCode;
+    readonly tag?: string;
+    readonly method?: string;
+    readonly previousState?: EntitlementState;
+}
+export declare class SyidaxLicenseError extends Error {
+    readonly code: LicenseDiagnosticCode;
+    readonly product: LicenseProduct;
+    readonly feature: string;
+    readonly state: EntitlementState;
+    readonly tag?: string;
+    readonly method?: string;
+    readonly reason?: string;
+    constructor(init: LicenseErrorInit);
+}
+export declare function createLicenseError(init: LicenseErrorInit): SyidaxLicenseError;
+export declare function isLicenseError(value: unknown): value is SyidaxLicenseError;
+export declare function dispatchLicenseEvent(target: EventTarget | null | undefined, type: LicenseEventType, detail: LicenseEventDetail): boolean;
+export declare function warnLicenseOnce(key: string, message: string): boolean;

package/dist/license/errors.js

@@ -0,0 +1 @@
+import{FEATURE_ID_PATTERN,LICENSE_PRODUCTS,WARNINGS_SYMBOL_KEY}from"./diagnostic-constants.js";export const LICENSE_ERROR_NAME="SyidaxLicenseError";export const LICENSE_STATE_CHANGED_EVENT="licenseStateChanged";export const LICENSE_FEATURE_REFUSED_EVENT="licenseFeatureRefused";export const LICENSE_ATTR=Object.freeze({state:"data-license-state",feature:"data-license-feature",frozen:"data-license-frozen",refused:"data-license-refused"});export const LICENSE_WARNING_PREFIX="[Syidax] ";export const MAX_LICENSE_WARNING_KEYS=256;const DIAGNOSTIC_CODES={"license-required":true,"license-pending":true,"module-missing":true,"load-failed":true,"engine-unsupported":true,disposed:true,stale:true};const ENTITLEMENT_STATES={none:true,pending:true,valid:true,insufficient:true,"not-yet-valid":true,expired:true,invalid:true,revoked:true,"unsupported-environment":true};const ENTITLEMENT_CODES={"no-certificate":true,"verification-pending":true,granted:true,"product-not-granted":true,"feature-not-granted":true,"grant-not-started":true,"grant-expired":true,"certificate-revoked":true,malformed:true,"too-large":true,"unsupported-alg":true,"unknown-kid":true,"bad-signature":true,"wrong-issuer":true,"wrong-audience":true,"wrong-environment":true,"wrong-organization":true,"schema-mismatch":true,"invalid-field":true,"stale-revision":true,revoked:true,"revocation-invalid":true,"cross-origin-url":true,"fetch-failed":true,"context-required":true,"unsupported-environment":true,superseded:true};const LICENSE_ID_TEXT=/(?:org|lf|cert)_[A-Za-z0-9_-]*/gi;const REDACTED="[redacted]";const MAX_NAME_LENGTH=128;const MAX_REASON_LENGTH=500;const MAX_MESSAGE_LENGTH=1e3;const MAX_WARNING_KEY_LENGTH=512;function has(table,value){return typeof value==="string"&&Object.prototype.hasOwnProperty.call(table,value)}function clean(text,maxLength){const redacted=text.replace(LICENSE_ID_TEXT,REDACTED);return redacted.length>maxLength?`${redacted.slice(0,maxLength-1)}…`:redacted}function textOf(value){if(typeof value==="string")return value;try{if(typeof value==="object"&&value!==null&&typeof value.message==="string"){return value.message}return String(value)}catch{return"unknown reason"}}function shown(value){return clean(typeof value==="string"?value:typeof value,64)}function optionalName(value,label){if(value===void 0)return void 0;if(typeof value!=="string"||value.length===0)throw new TypeError(`License diagnostic ${label} must be a non-empty string.`);return clean(value,MAX_NAME_LENGTH)}function subject(input,what){if(typeof input!=="object"||input===null)throw new TypeError(`${what} needs an object.`);const{product,feature,state,tag,method}=input;if(typeof product!=="string"||!LICENSE_PRODUCTS.includes(product)){throw new TypeError(`${what}: unknown product "${shown(product)}".`)}if(typeof feature!=="string"||!FEATURE_ID_PATTERN.test(feature)||!feature.startsWith(`${product}.`)){throw new TypeError(`${what}: feature must be a ${product} feature ID such as "${product}.<feature>".`)}if(!has(ENTITLEMENT_STATES,state))throw new TypeError(`${what}: unknown license state "${shown(state)}".`);const result={product,feature,state};const cleanTag=optionalName(tag,"tag");const cleanMethod=optionalName(method,"method");if(cleanTag!==void 0)result.tag=cleanTag;if(cleanMethod!==void 0)result.method=cleanMethod;return result}function defaultMessage(code,fields,reason){const where=fields.tag!==void 0?`<${fields.tag}>${fields.method!==void 0?`.${fields.method}()`:""}: `:fields.method!==void 0?`${fields.method}(): `:"";const feature=`"${fields.feature}"`;switch(code){case"license-required":return`${where}${feature} needs a valid ${fields.product} Pro license (license state: ${fields.state}).`;case"license-pending":return`${where}${feature} is waiting for the ${fields.product} license verification to finish.`;case"module-missing":return`${where}${feature} is licensed, but its module is not installed or not selected.`;case"load-failed":return`${where}${feature} could not load its module${reason!==void 0?` (${reason})`:""}.`;case"engine-unsupported":return`${where}${feature} is licensed, but this environment lacks the engine it needs.`;case"disposed":return`${where}${feature} was refused because the element was disposed.`;case"stale":return`${where}${feature} was abandoned because the ${fields.product} license changed while it was running.`}}export class SyidaxLicenseError extends Error{constructor(init){const fields=subject(init,"createLicenseError");const code=init.code;if(!has(DIAGNOSTIC_CODES,code))throw new TypeError(`createLicenseError: unknown code "${shown(code)}".`);const reason=init.reason===void 0?void 0:clean(textOf(init.reason),MAX_REASON_LENGTH);if(init.message!==void 0&&typeof init.message!=="string")throw new TypeError("createLicenseError: message must be a string.");const message=init.message!==void 0?clean(init.message,MAX_MESSAGE_LENGTH):defaultMessage(code,fields,reason);super(message);const target=this;target.code=code;target.product=fields.product;target.feature=fields.feature;target.state=fields.state;if(fields.tag!==void 0)target.tag=fields.tag;if(fields.method!==void 0)target.method=fields.method;if(reason!==void 0)target.reason=reason}}Object.defineProperty(SyidaxLicenseError.prototype,"name",{value:LICENSE_ERROR_NAME,writable:true,configurable:true,enumerable:false});export function createLicenseError(init){return new SyidaxLicenseError(init)}export function isLicenseError(value){try{if(typeof value!=="object"&&typeof value!=="function"||value===null)return false;const candidate=value;return candidate.name===LICENSE_ERROR_NAME&&has(DIAGNOSTIC_CODES,candidate.code)}catch{return false}}function eventDetail(detail){const fields=subject(detail,"dispatchLicenseEvent");const{code,previousState}=detail;if(!has(DIAGNOSTIC_CODES,code)&&!has(ENTITLEMENT_CODES,code))throw new TypeError(`dispatchLicenseEvent: unknown code "${shown(code)}".`);const result={product:fields.product,feature:fields.feature,state:fields.state,code};if(fields.tag!==void 0)result.tag=fields.tag;if(fields.method!==void 0)result.method=fields.method;if(previousState!==void 0){if(!has(ENTITLEMENT_STATES,previousState))throw new TypeError(`dispatchLicenseEvent: unknown previous state "${shown(previousState)}".`);result.previousState=previousState}return Object.freeze(result)}export function dispatchLicenseEvent(target,type,detail){if(type!==LICENSE_STATE_CHANGED_EVENT&&type!==LICENSE_FEATURE_REFUSED_EVENT){throw new TypeError(`dispatchLicenseEvent: unknown event type "${shown(type)}".`)}const cleanDetail=eventDetail(detail);const EventType=globalThis.CustomEvent;if(typeof EventType!=="function"||target===null||target===void 0||typeof target.dispatchEvent!=="function"){return false}return target.dispatchEvent(new EventType(type,{detail:cleanDetail,bubbles:true,composed:true}))}let privateWarnings;function isWarningRegistry(value){if(typeof value!=="object"||value===null)return false;const candidate=value;return candidate.version===1&&candidate.keys instanceof Set&&typeof candidate.suppressed==="boolean"}function warningRegistry(){try{const key=Symbol.for(WARNINGS_SYMBOL_KEY);const existing=globalThis[key];if(existing===void 0){const registry={version:1,keys:new Set,suppressed:false};Object.defineProperty(globalThis,key,{value:registry,configurable:false,enumerable:false,writable:false});return registry}if(isWarningRegistry(existing))return existing}catch{}privateWarnings??={version:1,keys:new Set,suppressed:false};return privateWarnings}function emitWarning(text){const sink=typeof console==="undefined"?void 0:console;if(!sink||typeof sink.warn!=="function")return false;sink.warn(`${LICENSE_WARNING_PREFIX}${text}`);return true}export function warnLicenseOnce(key,message){try{const id=String(key).slice(0,MAX_WARNING_KEY_LENGTH);const registry=warningRegistry();if(registry.keys.has(id))return false;if(registry.keys.size>=MAX_LICENSE_WARNING_KEYS){if(registry.suppressed)return false;registry.suppressed=true;emitWarning(`Further license warnings are suppressed on this page (${MAX_LICENSE_WARNING_KEYS} distinct warnings shown).`);return false}registry.keys.add(id);const text=clean(textOf(message),MAX_MESSAGE_LENGTH);return emitWarning(text.startsWith(LICENSE_WARNING_PREFIX)?text.slice(LICENSE_WARNING_PREFIX.length):text)}catch{return false}}

package/dist/license/evaluate.d.ts

@@ -0,0 +1,19 @@
+import type { CertificateGrant } from './certificate';
+import type { Failure } from './failure';
+import type { Entitlement, EntitlementCode, EntitlementState, LicenseFailure, LicenseProduct, LicenseStatusReport } from './types';
+import type { VerifiedCertificate, VerifiedRevocations } from './verify';
+export interface VerifiedLicenseState {
+    readonly certificateToken: string;
+    readonly revocationsToken: string | null;
+    readonly certificate: VerifiedCertificate | null;
+    readonly revocations: VerifiedRevocations | null;
+    readonly failure: Failure | null;
+}
+export declare function simpleEntitlement(product: LicenseProduct, feature: string | undefined, state: EntitlementState, code: EntitlementCode, message: string): Entitlement;
+export declare function refusedEntitlement(product: LicenseProduct, feature: string | undefined, refusal: LicenseFailure): Entitlement;
+export declare function coversRelease(grant: CertificateGrant, releasedAt: number): boolean;
+export declare function evaluateEntitlement(state: VerifiedLicenseState, product: LicenseProduct, feature: string | undefined, now: number, releasedAt?: number): Entitlement;
+export declare function scopedFeatureEntitlements(state: VerifiedLicenseState, now: number, releasedAt?: number | ((product: LicenseProduct) => number | undefined)): readonly Entitlement[];
+export declare function nextBoundary(state: VerifiedLicenseState, now: number): number | undefined;
+export declare function buildReport(context: string | null, entitlementOf: (product: LicenseProduct) => Entitlement, state: VerifiedLicenseState | null, lastFailure: LicenseFailure | null): LicenseStatusReport;
+export declare function reportKey(report: LicenseStatusReport, scopedFeatures?: readonly Entitlement[]): string;

package/dist/license/evaluate.js

@@ -0,0 +1 @@
+import{LICENSE_PRODUCTS}from"./constants.js";export function simpleEntitlement(product,feature,state,code,message){return Object.freeze(feature===void 0?{product,state,code,message}:{product,feature,state,code,message})}export function refusedEntitlement(product,feature,refusal){if(refusal.code==="revoked")return simpleEntitlement(product,feature,"revoked","certificate-revoked",refusal.message);const state=refusal.code==="unsupported-environment"?"unsupported-environment":"invalid";return simpleEntitlement(product,feature,state,refusal.code,refusal.message)}export function coversRelease(grant,releasedAt){return grant.updatesUntilMs>grant.validFromMs&&releasedAt<=grant.updatesUntilMs}export function evaluateEntitlement(state,product,feature,now,releasedAt=Number.POSITIVE_INFINITY){if(state.failure)return refusedEntitlement(product,feature,state.failure);const certificate=state.certificate;const claims=certificate.claims;if(state.revocations?.revokedCertificateIds.has(claims.certificateId)){return certificateEntitlement(certificate,product,feature,"revoked","certificate-revoked","The certificate is on the signed revocation list.")}const scope=feature===void 0?`${product} Pro`:`"${feature}"`;if(feature!==void 0&&!feature.startsWith(`${product}.`)){return certificateEntitlement(certificate,product,feature,"insufficient","feature-not-granted",`${scope} is not a ${product} feature.`)}let productGranted=false;let active=null;let upcoming=null;let ended=null;let fallback=null;for(const grant of claims.grants){if(grant.product!==product)continue;productGranted=true;const covers=grant.allFeatures||feature!==void 0&&grant.features.includes(feature);if(!covers)continue;if(now<grant.validFromMs){if(!upcoming||grant.validFromMs<upcoming.validFromMs)upcoming=grant}else if(now<grant.paidThroughMs){if(!active||grant.paidThroughMs>active.paidThroughMs)active=grant}else{if(!ended||grant.paidThroughMs>ended.paidThroughMs)ended=grant;if(claims.policy.endsWith("-annual")&&coversRelease(grant,releasedAt)&&(!fallback||grant.updatesUntilMs>fallback.updatesUntilMs))fallback=grant}}if(active){return certificateEntitlement(certificate,product,feature,"valid","granted",`${scope} is licensed until ${active.paidThrough}.`,active)}if(fallback){return certificateEntitlement(certificate,product,feature,"valid","granted",`${scope} paid period ended at ${fallback.paidThrough}; this release stays licensed because it was released by ${fallback.updatesUntil}.`,fallback)}if(upcoming){return certificateEntitlement(certificate,product,feature,"not-yet-valid","grant-not-started",`${scope} starts at ${upcoming.validFrom}.`,upcoming)}if(ended){const newer=claims.policy.endsWith("-annual")&&ended.updatesUntilMs>ended.validFromMs?` This release is newer than ${ended.updatesUntil}, the last release the license keeps.`:"";return certificateEntitlement(certificate,product,feature,"expired","grant-expired",`${scope} paid period ended at ${ended.paidThrough}.${newer}`,ended)}if(!productGranted){return certificateEntitlement(certificate,product,feature,"insufficient","product-not-granted",`The certificate has no ${product} grant.`)}return feature===void 0?certificateEntitlement(certificate,product,feature,"insufficient","product-not-granted",`The certificate grants only specific ${product} features.`):certificateEntitlement(certificate,product,feature,"insufficient","feature-not-granted",`The certificate does not grant ${scope}.`)}function certificateEntitlement(certificate,product,feature,state,code,message,grant){const claims=certificate.claims;const entitlement={product,state,code,message,revision:claims.revision,certificateId:claims.certificateId,organizationRef:claims.organizationRef};if(feature!==void 0)entitlement.feature=feature;if(grant){entitlement.validFrom=grant.validFrom;entitlement.paidThrough=grant.paidThrough}return Object.freeze(entitlement)}export function scopedFeatureEntitlements(state,now,releasedAt){if(state.failure||!state.certificate)return[];const features=new Map;for(const grant of state.certificate.claims.grants){if(grant.allFeatures)continue;for(const feature of grant.features)features.set(feature,grant.product)}return[...features.keys()].sort().map(feature=>evaluateEntitlement(state,features.get(feature),feature,now,typeof releasedAt==="function"?releasedAt(features.get(feature)):releasedAt))}export function nextBoundary(state,now){if(state.failure||!state.certificate)return void 0;if(state.revocations?.revokedCertificateIds.has(state.certificate.claims.certificateId))return void 0;for(const instant of state.certificate.boundaries){if(instant>now)return instant}return void 0}export function buildReport(context,entitlementOf,state,lastFailure){const products={};for(const product of LICENSE_PRODUCTS)products[product]=entitlementOf(product);const trusted=state!==null&&state.failure===null?state:null;return Object.freeze({context,products:Object.freeze(products),certificate:trusted?.certificate?.summary??null,revocationSequence:trusted?.revocations?.sequence??null,lastFailure})}export function reportKey(report,scopedFeatures=[]){const parts=[report.certificate?.certificateId??null,report.certificate?.revision??null,report.revocationSequence];for(const product of LICENSE_PRODUCTS){const entitlement=report.products[product];parts.push(entitlement.state,entitlement.code,entitlement.validFrom??null,entitlement.paidThrough??null)}for(const entitlement of scopedFeatures){parts.push(entitlement.feature??null,entitlement.state,entitlement.code,entitlement.validFrom??null,entitlement.paidThrough??null)}return JSON.stringify(parts)}

package/dist/license/failure.d.ts

@@ -0,0 +1,11 @@
+import type { LicenseErrorCode } from './types';
+export interface Failure {
+    readonly ok: false;
+    readonly code: LicenseErrorCode;
+    readonly message: string;
+}
+export declare function failure(code: LicenseErrorCode, message: string): Failure;
+export declare function isFailure<T>(result: T | Failure): result is Failure;
+export declare function contextRequiredError(): Error & {
+    readonly code: 'context-required';
+};

package/dist/license/failure.js

@@ -0,0 +1 @@
+export function failure(code,message){return{ok:false,code,message}}export function isFailure(result){return result.ok===false}export function contextRequiredError(){const error=new Error("No license context: pass { context } or { document }. Server rendering has no default document context.");error.name="LicenseContextError";error.code="context-required";return error}

package/dist/license/fetch-license.d.ts

@@ -0,0 +1,12 @@
+import type { Failure } from './failure';
+import type { TimerApi } from './timers';
+export interface SameOriginTarget {
+    readonly ok: true;
+    readonly href: string;
+    readonly origin: string;
+}
+export declare function resolveSameOriginUrl(url: unknown, document: object | undefined): SameOriginTarget | Failure;
+export declare function fetchLicenseText(target: SameOriginTarget, fetchImpl: typeof fetch | undefined, timeoutMs: number, timers: TimerApi): Promise<{
+    ok: true;
+    text: string;
+} | Failure>;

package/dist/license/fetch-license.js

@@ -0,0 +1 @@
+import{MAX_LICENSE_FILE_LENGTH}from"./constants.js";import{failure}from"./failure.js";export function resolveSameOriginUrl(url,document){if(typeof url!=="string"||url.trim().length===0)return failure("malformed","License URL must be a non-empty string.");const page=pageLocation(document);if(!page)return failure("cross-origin-url","No document origin to compare the license URL against.");let pageUrl;let target;try{pageUrl=new URL(page.url);target=new URL(url,page.base)}catch{return failure("malformed","License URL is not a valid URL.")}if(!isHttp(pageUrl)||!isHttp(target)||target.origin!==pageUrl.origin){return failure("cross-origin-url","License files are only loaded from the page origin.")}return{ok:true,href:target.href,origin:target.origin}}function pageLocation(document){if(document){const{URL:url,baseURI}=document;if(!url)return void 0;return{url,base:baseURI||url}}const href=globalThis.location?.href;return href?{url:href,base:href}:void 0}function isHttp(url){return url.protocol==="http:"||url.protocol==="https:"}export async function fetchLicenseText(target,fetchImpl,timeoutMs,timers){if(typeof fetchImpl!=="function")return failure("fetch-failed","fetch is not available in this environment.");const controller=typeof AbortController==="function"?new AbortController:void 0;let timer;const timeout=new Promise(resolve=>{timer=timers.setTimeout(()=>{controller?.abort();resolve(failure("fetch-failed",`License file request timed out after ${timeoutMs} ms.`))},timeoutMs)});try{return await Promise.race([download(target,fetchImpl,controller?.signal),timeout])}finally{timers.clearTimeout(timer)}}async function download(target,fetchImpl,signal){let response;try{response=await fetchImpl(target.href,{method:"GET",credentials:"same-origin",cache:"no-cache",headers:{accept:"application/json"},...signal?{signal}:{}})}catch{return failure("fetch-failed","License file request failed.")}if(response.url){let finalOrigin;try{finalOrigin=new URL(response.url).origin}catch{finalOrigin=void 0}if(finalOrigin!==target.origin)return failure("cross-origin-url","License file request was redirected to another origin.")}if(!response.ok)return failure("fetch-failed",`License file request returned HTTP ${response.status}.`);const declaredLength=Number(response.headers?.get?.("content-length")??NaN);if(declaredLength>MAX_LICENSE_FILE_LENGTH)return failure("too-large",`License file exceeds ${MAX_LICENSE_FILE_LENGTH} bytes.`);let text;try{text=await response.text()}catch{return failure("fetch-failed","License file body could not be read.")}if(text.length>MAX_LICENSE_FILE_LENGTH)return failure("too-large",`License file exceeds ${MAX_LICENSE_FILE_LENGTH} characters.`);return{ok:true,text}}