@formata/limitr 0.5.13

package/dist/main.js

@@ -0,0 +1,746 @@
+//
+// Copyright 2026 Formata, Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+import { StofDoc } from "@formata/stof";
+import { limitrApi } from "./limitr.js";
+import { LimitrGate, waitOnOpen } from "./gate.js";
+/**
+ * Limitr monetization policy.
+ */
+export class Limitr {
+    /**
+     * Constructor.
+     * Make sure StofDoc.initialize() has been called for Stof first.
+     */
+    constructor(policy = 'Limitr policy: {}', format = 'stof') {
+        /** Gate. */
+        this.gate = new LimitrGate();
+        /** Deny allows if cloud connection interrupted (recommended)? */
+        this.denyUnconnected = true;
+        this.wsInit = false;
+        /** Optional named event handlers for all Limitr events. */
+        this.eventHandlers = new Map();
+        /**
+         * Send on the cloud WebSocket if enabled.
+         */
+        this._dataSendQueue = [];
+        /**
+         * Cloud message received.
+         */
+        this._deniedCloudCustomers = new Set();
+        this.doc = new StofDoc();
+        this.doc.parse(limitrApi, 'bstf');
+        this.doc.parse(policy, format);
+    }
+    /**
+     * Add an event handler by name to this Limitr policy.
+     */
+    addHandler(name, handler) {
+        this.eventHandlers.set(name, handler);
+        this.doc.lib('App', 'event_handler', (key, value) => {
+            for (const [_, handler] of this.eventHandlers)
+                handler(key, value);
+        });
+    }
+    /**
+     * Remove an event handler by name.
+     */
+    removeHandler(name) {
+        return this.eventHandlers.delete(name);
+    }
+    /**
+     * Clear event handlers.
+     */
+    clearHandlers() {
+        this.eventHandlers = new Map();
+    }
+    /**
+     * Async constructor that ensures Stof wasm initialization.
+     */
+    static async new(policy = 'Limitr policy: {}', format = 'stof') {
+        await StofDoc.initialize();
+        return new Limitr(policy, format);
+    }
+    /**
+     * Call a specific Stof function in this doc by path/name through the gate.
+     * For complex use-cases, create your own StofDoc.
+     */
+    async docCall(path, ...args) {
+        return await this.gate.run(() => this.doc.call(path, ...args));
+    }
+    /*****************************************************************************
+     * Plans API.
+     *****************************************************************************/
+    /**
+     * Get a plan record by ID (plan ID or customer ID).
+     */
+    async plan(id, def = true) {
+        const planNode = await this.gate.run(() => this.doc.sync_call('<Limitr>.api.plan', id, def));
+        if (typeof planNode === 'string')
+            return this.doc.record(planNode);
+        return undefined;
+    }
+    /**
+     * Get the default plan if any.
+     */
+    async defaultPlan() {
+        const planNode = await this.gate.run(() => this.doc.sync_call('<Limitr>.api.default_plan'));
+        if (typeof planNode === 'string')
+            return this.doc.record(planNode);
+        return undefined;
+    }
+    /**
+     * Get a plan price by ID (plan ID or customer ID).
+     */
+    async planPrice(id) {
+        const priceNode = await this.gate.run(() => this.doc.sync_call('<Limitr>.api.plan_price', id));
+        if (typeof priceNode === 'string')
+            return this.doc.record(priceNode);
+        return undefined;
+    }
+    /**
+     * Get a plan price ID.
+     */
+    async planPriceId(id) {
+        return await this.gate.run(() => this.doc.sync_call('<Limitr>.api.plan_price_id', id));
+    }
+    /**
+     * Get a plan amount.
+     */
+    async planAmount(id) {
+        return await this.gate.run(() => this.doc.sync_call('<Limitr>.api.plan_amount', id));
+    }
+    /**
+     * Get a plan price label.
+     */
+    async planPriceLabel(id) {
+        return await this.gate.run(() => this.doc.sync_call('<Limitr>.api.plan_price_label', id));
+    }
+    /**
+     * Set a plan on this policy by name/ID.
+     * Returns a node ID to the resulting Plan.
+     */
+    async setPlan(id, planStof) {
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.set_plan', id, planStof));
+    }
+    /**
+     * Delete a plan by ID.
+     */
+    async deletePlan(id) {
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.delete_plan', id));
+    }
+    /*****************************************************************************
+     * Credits API.
+     *****************************************************************************/
+    /**
+     * Get a credit record by ID/type.
+     */
+    async credit(id) {
+        const node = await this.gate.run(() => this.doc.sync_call('<Limitr>.api.credit', id));
+        if (typeof node === 'string')
+            return this.doc.record(node);
+        return undefined;
+    }
+    /**
+     * Get a credit record for a specific entitlement.
+     * ID can be a plan ID or a customer ID.
+     */
+    async creditFor(id, entitlement) {
+        const node = await this.gate.run(() => this.doc.sync_call('<Limitr>.api.credit_for', id, entitlement));
+        if (typeof node === 'string')
+            return this.doc.record(node);
+        return undefined;
+    }
+    /*****************************************************************************
+     * Customers API.
+     *****************************************************************************/
+    /**
+     * Get a customer record by ID (or alternative IDs).
+     */
+    async customer(id) {
+        const subNode = await this.gate.run(() => this.doc.sync_call('<Limitr>.api.customer', id));
+        if (typeof subNode === 'string')
+            return this.doc.record(subNode);
+        return undefined;
+    }
+    /**
+     * Get a customer metadata object (if any).
+     */
+    async customerMetadata(id) {
+        const metaNode = await this.gate.run(() => this.doc.sync_call('<Limitr>.api.customer_metadata', id));
+        if (typeof metaNode === 'string')
+            return this.doc.record(metaNode);
+        return undefined;
+    }
+    /**
+     * Get all customers as a single record.
+     * Customers contain all state information, so this is all that is required to save/load.
+     */
+    async customers() {
+        const node = await this.gate.run(() => this.doc.sync_call('<Limitr>.api.get'));
+        if (typeof node === 'string') {
+            const subs = this.doc.get('customers', node);
+            if (typeof subs === 'string')
+                return this.doc.record(subs);
+        }
+        return undefined;
+    }
+    /**
+     * Get the customer reference IDs for a customer.
+     */
+    async customerRefs(id) {
+        return await this.gate.run(() => this.doc.sync_call('<Limitr>.api.customer_refs', id));
+    }
+    /**
+     * Set/change a customer's plan by plan ID.
+     * Returns true if the plan has changed (and emits customer-set & customer-plan-changed events).
+     */
+    async setCustomerPlan(id, plan, overwrite_meters = true) {
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.set_customer_plan', id, plan, overwrite_meters));
+    }
+    /**
+     * Ensure that a customer exists, creating one if necessary.
+     * This takes the cloud into consideration as well.
+     * Returns true if a new customer was created.
+     */
+    async ensureCustomer(id, plan = '', type = 'user', label = 'User', refs = null, alts = null, metadata = null) {
+        const existing = await this.gate.run(() => this.doc.sync_call('<Limitr>.api.customer', id));
+        if (existing)
+            return false;
+        if (this.ws) {
+            switch (this.ws.readyState) {
+                case WebSocket.OPEN: {
+                    if (await this.addCloudCustomer(id))
+                        return false;
+                    break;
+                }
+                case WebSocket.CONNECTING: {
+                    await waitOnOpen(this.ws);
+                    if (await this.addCloudCustomer(id))
+                        return false;
+                    break;
+                }
+                case WebSocket.CLOSING:
+                case WebSocket.CLOSED: {
+                    if (this.denyUnconnected)
+                        return false;
+                    break;
+                }
+            }
+        }
+        let meta = null;
+        if (typeof metadata === 'string')
+            meta = metadata;
+        else if (metadata)
+            meta = JSON.stringify(metadata);
+        await this.gate.run(() => this.doc.call('<Limitr>.api.create_customer', id, plan, type, label, refs, alts, meta));
+        return true;
+    }
+    /**
+     * Create a new customer and add to this Limitr.
+     * Use a unique ID - can always add additional unique IDs with alts (Ex. Stripe customer ID, API key, etc.).
+     * Note: prefer ensureCustomer API in case this customer already exists.
+     */
+    async createCustomer(id, plan = '', type = 'user', label = 'User', refs = null, alts = null, metadata = null) {
+        let meta = null;
+        if (typeof metadata === 'string')
+            meta = metadata;
+        else if (metadata)
+            meta = JSON.stringify(metadata);
+        await this.gate.run(() => this.doc.call('<Limitr>.api.create_customer', id, plan, type, label, refs, alts, meta));
+    }
+    /**
+     * Ensure that a customer exists, creating one by record if necessary.
+     * This takes the cloud into consideration as well.
+     * Returns true if a new customer was created.
+     */
+    async ensureSetCustomer(customer, event = true) {
+        const record = typeof customer === 'string' ? JSON.parse(customer) : customer;
+        const id = record.id;
+        if (!id)
+            throw new Error('Ensure setting a customer expects a customer record with an ID');
+        const existing = await this.gate.run(() => this.doc.sync_call('<Limitr>.api.customer', id));
+        if (existing)
+            return false;
+        if (this.ws) {
+            switch (this.ws.readyState) {
+                case WebSocket.OPEN: {
+                    if (await this.addCloudCustomer(id))
+                        return false;
+                    break;
+                }
+                case WebSocket.CONNECTING: {
+                    await waitOnOpen(this.ws);
+                    if (await this.addCloudCustomer(id))
+                        return false;
+                    break;
+                }
+                case WebSocket.CLOSING:
+                case WebSocket.CLOSED: {
+                    if (this.denyUnconnected)
+                        return false;
+                    break;
+                }
+            }
+        }
+        const res = await this.gate.run(() => this.doc.call('<Limitr>.api.set_customer', JSON.stringify(record), event));
+        return !!res;
+    }
+    /**
+     * Set a customer on this policy by ID.
+     * Returns a node ID to the resulting Customer.
+     */
+    async setCustomer(customer, event = true) {
+        const customerStof = typeof customer === 'string' ? customer : JSON.stringify(customer);
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.set_customer', customerStof, event));
+    }
+    /**
+     * Load many customers as records.
+     * This is all that is required for save/load since customers contain all state information.
+     */
+    async loadCustomers(customers) {
+        let subs = [];
+        if (!Array.isArray(customers)) {
+            for (const [k, v] of Object.entries(customers)) {
+                const val = v;
+                val.id = k; // make sure it has the correct ID
+                subs.push(val);
+            }
+        }
+        else {
+            subs = customers;
+        }
+        const handles = [];
+        for (const sub of subs) {
+            const id = sub.id;
+            if (typeof id === 'string') {
+                handles.push(this.setCustomer(JSON.stringify(sub)));
+            }
+        }
+        await Promise.allSettled(handles);
+    }
+    /**
+     * Remove a customer by ID.
+     * If a cloud customer, they will not be removed from the cloud.
+     */
+    async removeCustomer(id) {
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.delete_customer', id));
+    }
+    /**
+     * Add an alternative customer ID to an existing customer.
+     */
+    async addAltID(existing, alt, event = true) {
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.set_alt_customer_id', existing, alt, event));
+    }
+    /**
+     * Remove an alternative customer ID from an existing customer.
+     */
+    async removeAltID(alt, event = true) {
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.delete_alt_customer_id', alt, event));
+    }
+    /**
+     * Create a new customer override (limit).
+     * Overrides are specific to customers, and they override the limit defined on a specific entitlement for that customer.
+     *
+     * If the customer already has an override for this entitlement, it will be replaced.
+     */
+    async createCustomerOverride(id, entitlement, value, expires_on, credit, mode, increment, resets, reset_inc) {
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.create_customer_override', id, entitlement, expires_on ?? null, credit ?? null, mode ?? null, value ?? null, increment ?? null, resets ?? null, reset_inc ?? null));
+    }
+    /**
+     * Remove a customer override (limit).
+     */
+    async removeCustomerOverride(id, entitlement) {
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.remove_customer_override', id, entitlement));
+    }
+    /**
+     * Create a customer credit grant (recommended use in top-ups & one-time purchases).
+     * Grants are applied when overage would occur (soft entitlement limits).
+     * Defaults to a one-time, fixed-value credit grant.
+     * More than one grant with the same "credit" can exist alongside one another.
+     * Do not sync grants up with plans - if a plan includes a credit grant, just set a soft limit value (same thing).
+     *
+     * Ex. a soft limit of 5k tokens + a grant of 2k tokens would result in the customer
+     * getting overage events (meter-overage) after 7k tokens spent.
+     *
+     * @returns true when the customer & credit exists, meaning the grant has been applied.
+     */
+    async create_customer_credit_grant(id, credit, value, resets = false, reset_inc, expires_on) {
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.create_customer_credit_grant', id, credit, value, resets, reset_inc ?? null, expires_on ?? null));
+    }
+    /*****************************************************************************
+     * Entitlements API.
+     *****************************************************************************/
+    /**
+     * Get an entitlement record with a plan ID or customer ID and an entitlement name.
+     */
+    async entitlement(id, entitlement) {
+        const node = await this.gate.run(() => this.doc.sync_call('<Limitr>.api.entitlement', id, entitlement));
+        if (typeof node === 'string')
+            return this.doc.record(node);
+        return undefined;
+    }
+    /**
+     * Get the limit value for a metered entitlement.
+     * ID can be a customer ID or a plan ID (to get the specific entitlement from a plan).
+     * Will always be in the units of the credit associated with this entitlement (ex. limit.value = '2GB', credit.stof_units = 'MB', limit = 2000).
+     */
+    async limit(id, entitlement) {
+        return await this.gate.run(() => this.doc.sync_call('<Limitr>.api.limit', id, entitlement));
+    }
+    /**
+     * Get the remaining balance for a customer's entitlement (limit - current (metered) value).
+     * Will always be in the units of the credit associated with this entitlement.
+     */
+    async remaining(customer, entitlement) {
+        if (!await this.cloudPreCheckContinue(customer))
+            return null;
+        return await this.gate.run(() => this.doc.sync_call('<Limitr>.api.remaining', customer, entitlement));
+    }
+    /**
+     * Get the current meter value for a customer's entitlement.
+     * Will always be in the units of the credit associated with this entitlement.
+     */
+    async value(customer, entitlement) {
+        if (!await this.cloudPreCheckContinue(customer))
+            return null;
+        return await this.gate.run(() => this.doc.sync_call('<Limitr>.api.value', customer, entitlement));
+    }
+    /**
+     * Get the cost for a standard increment on an entitlement (if set on its limit).
+     */
+    async cost(id, entitlement) {
+        return await this.gate.run(() => this.doc.sync_call('<Limitr>.api.cost', id, entitlement));
+    }
+    /**
+     * Try changing the value of a metered entitlement using a standard increment (defined in the Limit).
+     * This is the same as using "meter" with the "cost" of a standard increment for this entitlement.
+     * Returns true if changed and the limit was not hit, otherwise false and App.meter_limit lib func will be called (if present).
+     * Can use a string value for units in entitlement.limit.increment (must be a valid stof number) (ex. '3GiB' or '5s').
+     */
+    async increment(customer, entitlement) {
+        if (!await this.cloudPreCheckContinue(customer))
+            return false;
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.increment', customer, entitlement));
+    }
+    /**
+     * Try changing the value of a metered entitlement by removing a standard increment (defined in the Limit).
+     * This is the same as using "meter" with the negative "cost" of a standard increment for this entitlement.
+     * Can use a string value for units in entitlement.limit.increment (must be a valid stof number) (ex. '3GiB' or '5s').
+     */
+    async deincrement(customer, entitlement) {
+        if (!await this.cloudPreCheckContinue(customer))
+            return false;
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.deincrement', customer, entitlement));
+    }
+    /**
+     * Allow changing this entitlement by "value" for this customer?
+     * A boolean entitlement check if value is 0 or a limit does not exist for the entitlement (bool flag).
+     * Changes a meter for this customer if true.
+     * Can use a string value for units (must be a valid stof number) (ex. '3GiB' or '5s').
+     */
+    async allow(customer, entitlement, value = 0) {
+        if (!await this.cloudPreCheckContinue(customer))
+            return false;
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.allow', customer, entitlement, value));
+    }
+    /**
+     * Would a "check" call work for this entitlement and increment value on this customer?
+     * Does not change a meter (charge usage) for this customer, just checks if it would work.
+     */
+    async checkIncrement(customer, entitlement) {
+        if (!await this.cloudPreCheckContinue(customer))
+            return false;
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.check_increment', customer, entitlement));
+    }
+    /**
+     * Would a "check" call work for this entitlement and deincrement value on this customer?
+     * Does not change a meter (charge usage) for this customer, just checks if it would work.
+     */
+    async checkDeincrement(customer, entitlement) {
+        if (!await this.cloudPreCheckContinue(customer))
+            return false;
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.check_deincrement', customer, entitlement));
+    }
+    /**
+     * Would an "allow" call work for this entitlement and value on this customer?
+     * Does not change a meter (charge usage) for this customer, just checks if it would work.
+     * Can use a string value for units (must be a valid stof number) (ex. '3GiB' or '5s').
+     */
+    async check(customer, entitlement, value = 0) {
+        if (!await this.cloudPreCheckContinue(customer))
+            return false;
+        return await this.gate.run(() => this.doc.call('<Limitr>.api.check', customer, entitlement, value));
+    }
+    /*****************************************************************************
+     * Limitr Cloud.
+     *****************************************************************************/
+    /**
+     * Initialize with cloud.limitr.dev.
+     *
+     * @param token API token.
+     * @param address (optional) Server URL.
+     * @param policy (optional) Policy ID or "active" for the active policy.
+     * @param connectTimeout (optional) Time to wait when establishing an initial connection (ms).
+     */
+    static async cloud(options) {
+        const token = typeof options === 'string' ? options : options.token;
+        if (token.length < 1)
+            return undefined;
+        const policy = typeof options === 'string' ? 'active' : options.policy ?? 'active';
+        const address = typeof options === 'string' ? 'wss://api.limitr.dev' : options.wsAddress ?? 'wss://api.limitr.dev';
+        const ticketAddress = typeof options === 'string' ? 'https://api.limitr.dev' : options.ticketAddress ?? 'https://api.limitr.dev';
+        const timeout = typeof options === 'string' ? 5000 : options.connectTimeout ?? 5000;
+        const denyUnconnected = typeof options === 'string' ? true : options.denyUnconnected ?? true;
+        const response = await fetch(ticketAddress + '/wss/ticket', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ token })
+        });
+        if (!response.ok)
+            return undefined;
+        const { ticket } = await response.json();
+        const ws = new WebSocket(address + '/wss?ticket=' + ticket);
+        ws.binaryType = 'arraybuffer';
+        const waitOpen = waitOnOpen(ws);
+        const limitr = await Limitr.new();
+        limitr.denyUnconnected = denyUnconnected;
+        const awaitInit = async () => {
+            await new Promise((resolve, reject) => {
+                const intervalMs = 50;
+                const start = Date.now();
+                const poll = () => {
+                    if (limitr.wsInit) {
+                        resolve(true);
+                        return;
+                    }
+                    if (Date.now() - start > timeout) {
+                        reject(new Error(`wait for WebSocket policy init timed out`));
+                        return;
+                    }
+                    setTimeout(poll, intervalMs);
+                };
+                poll();
+            });
+        };
+        const reconnect = async () => {
+            const response = await fetch(ticketAddress + '/wss/ticket', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ token })
+            });
+            if (response.ok) {
+                const { ticket } = await response.json();
+                const ws = new WebSocket(address + '/wss?ticket=' + ticket);
+                ws.binaryType = 'arraybuffer';
+                limitr.ws = ws;
+                limitr.ws.onclose = reconnect;
+                limitr.ws.onmessage = (m) => limitr.cloudMessageReceived(m);
+                await waitOnOpen(ws);
+            }
+        };
+        limitr.ws = ws;
+        limitr.ws.onclose = reconnect;
+        limitr.ws.onmessage = (m) => limitr.cloudMessageReceived(m);
+        await waitOpen;
+        limitr.ws.send(JSON.stringify({ type: 'policy', id: policy, format: 'bstf' }));
+        await awaitInit();
+        const ping = async () => {
+            if (!limitr.ws || limitr.ws.readyState === WebSocket.CLOSED || limitr.ws.readyState === WebSocket.CLOSING) {
+                await reconnect();
+            }
+            else if (limitr.ws.readyState === WebSocket.OPEN) {
+                if (limitr._dataSendQueue.length > 0) {
+                    for (const data of limitr._dataSendQueue)
+                        limitr.ws.send(data);
+                    limitr._dataSendQueue = [];
+                }
+                limitr.ws.send('ping');
+            }
+            limitr.wsTimeout = setTimeout(ping, 20000);
+        };
+        limitr.wsTimeout = setTimeout(ping, 20000);
+        if (limitr._dataSendQueue.length > 0 && limitr.ws.readyState === WebSocket.OPEN) {
+            for (const data of limitr._dataSendQueue)
+                limitr.ws.send(data);
+            limitr._dataSendQueue = [];
+        }
+        return limitr;
+    }
+    /**
+     * Add a customer from the cloud.
+     * Default is to wait 3 seconds before moving on.
+     */
+    async addCloudCustomer(id, timeout = 3000) {
+        const existing = await this.gate.run(() => this.doc.sync_call('<Limitr>.api.customer', id));
+        if (existing || !this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return false;
+        this._deniedCloudCustomers.delete(id);
+        this.ws.send(JSON.stringify({ type: 'customer', id }));
+        return new Promise((resolve) => {
+            const intervalMs = 50;
+            const start = Date.now();
+            const poll = async () => {
+                if (await this.gate.run(() => this.doc.sync_call('<Limitr>.api.customer', id))) {
+                    resolve(true);
+                    return;
+                }
+                if (this._deniedCloudCustomers.has(id)) {
+                    this._deniedCloudCustomers.delete(id);
+                    resolve(false);
+                    return;
+                }
+                if (Date.now() - start > timeout) {
+                    resolve(false);
+                    return;
+                }
+                setTimeout(poll, intervalMs);
+            };
+            poll();
+        });
+    }
+    /**
+     * Cloud pre-check.
+     */
+    async cloudPreCheckContinue(customer) {
+        if (this.ws) {
+            switch (this.ws.readyState) {
+                case WebSocket.OPEN: {
+                    const existing = await this.gate.run(() => this.doc.sync_call('<Limitr>.api.customer', customer));
+                    if (!existing)
+                        return await this.addCloudCustomer(customer);
+                    break;
+                }
+                case WebSocket.CONNECTING: {
+                    await waitOnOpen(this.ws);
+                    const existing = await this.gate.run(() => this.doc.sync_call('<Limitr>.api.customer', customer));
+                    if (!existing)
+                        return await this.addCloudCustomer(customer);
+                    break;
+                }
+                case WebSocket.CLOSING:
+                case WebSocket.CLOSED: {
+                    if (this.denyUnconnected)
+                        return false;
+                    break;
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * Close connection to cloud.limitr.dev.
+     */
+    close() {
+        //@ts-ignore timeout
+        if (this.wsTimeout)
+            clearTimeout(this.wsTimeout);
+        this.wsInit = false;
+        if (this.ws && this.ws.readyState !== WebSocket.CLOSED && this.ws.readyState !== WebSocket.CLOSING) {
+            this.ws.onclose = () => { }; // clear any auto re-connect behavior
+            this.ws.close();
+        }
+    }
+    async wsSend(data) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            if (this._dataSendQueue.length > 0) {
+                for (const data of this._dataSendQueue)
+                    this.ws.send(data);
+                this._dataSendQueue = [];
+            }
+            this.ws.send(data);
+        }
+        else if (this.ws && this.ws.readyState === WebSocket.CONNECTING) {
+            await waitOnOpen(this.ws);
+            if (this._dataSendQueue.length > 0) {
+                for (const data of this._dataSendQueue)
+                    this.ws.send(data);
+                this._dataSendQueue = [];
+            }
+            this.ws.send(data);
+        }
+        else {
+            this._dataSendQueue.push(data);
+        }
+    }
+    //deno-lint-ignore no-explicit-any
+    async cloudMessageReceived(message) {
+        const data = message.data;
+        if (typeof data === 'string') {
+            if (data === 'pong' || data === 'ping')
+                return;
+            try {
+                const record = JSON.parse(data);
+                if (!!record.error && !!record.id) {
+                    if (record.type === 'customer') {
+                        this._deniedCloudCustomers.add(record.id);
+                    }
+                }
+                else if (!!record.policy && !!record.policy.plans) {
+                    await this.gate.run(() => this.doc.sync_call('<Limitr>.api.update_policy_internals', data, 'json'));
+                }
+                else if (record.type === 'customer-invoices' && !!record.data.invoices && !!record.id) {
+                    await this.gate.run(() => this.doc.sync_call('<Limitr>.api.update_customer_invoices', data, 'json'));
+                }
+                else if (!!record.type && !!record.id) {
+                    await this.gate.run(() => this.doc.sync_call('<Limitr>.api.update_customer_internals', data, 'json'));
+                }
+            }
+            catch {
+                // nada..
+            }
+        }
+        else {
+            try {
+                let buffer;
+                if (data instanceof ArrayBuffer) {
+                    buffer = new Uint8Array(data);
+                }
+                else if (data instanceof Blob) {
+                    buffer = new Uint8Array(await data.arrayBuffer());
+                }
+                else {
+                    return; // unknown binary type
+                }
+                this.doc = new StofDoc();
+                this.doc.parse(buffer, 'bstf');
+                this.doc.lib('Http', 'fetch', async (url, method = 'GET', body = null, headers = new Map()) => {
+                    const response = await fetch(url, {
+                        method,
+                        body: body ?? undefined,
+                        headers: Object.fromEntries(headers.entries()),
+                    });
+                    const result = new Map();
+                    result.set('status', response.status);
+                    result.set('ok', response.ok);
+                    const headerMap = new Map();
+                    response.headers.forEach((value, key) => headerMap.set(key, value));
+                    result.set('headers', headerMap);
+                    result.set('content_type', response.headers.get('content-type') ?? response.headers.get('Content-Type') ?? 'text/plain');
+                    result.set('bytes', await response.bytes());
+                    return result;
+                }, true);
+                this.doc.lib('CloudWS', 'send', (data) => {
+                    this.wsSend(data);
+                });
+                this.wsInit = true;
+            }
+            catch (e) {
+                console.error('Error initializing Limitr Policy from BSTF: ', e);
+            }
+        }
+    }
+}
+//# sourceMappingURL=main.js.map