@shiprev/server-sdk-node 0.0.0-stage → 0.1.0-beta.1

package/dist/client/shiprev-client.d.ts

@@ -0,0 +1,139 @@
+import { UsageBuffer } from '../metering/usage-buffer';
+import { HttpTransport } from '../transport/http.transport';
+import { AdjudicateOptions, ClientState, ConfirmReservationResult, EffectiveLevel, ReleaseReservationResult, ReservationResult, ReserveOptions, Ruling, ShipRevClientOptions, Snapshot, TokenClaims, UsageEventItem, UsageSendEvent, UsageSendResult } from '../types';
+export declare class ShipRevClient {
+    private readonly options;
+    private readonly transport;
+    private readonly tokenVerifier;
+    private readonly mirror;
+    private readonly adjudicator;
+    private readonly usageBuffer;
+    private readonly supervisor;
+    /** COLD until start() or setOnline(); otherwise the state follows the online signal and the mirror. */
+    private active;
+    private isOnline;
+    /** Issuer and application expected of session tokens, learned from the machine token. */
+    private expectations;
+    /** Amounts reserved by this client, so `confirm()` without an amount confirms what was reserved. */
+    private readonly reservedAmounts;
+    /** Effective levels last reported through `on_level_change`. */
+    private readonly reportedLevels;
+    /** Fires when the earliest `valid_until` passes while disconnected, to report the expiry. */
+    private expiryTimer;
+    constructor(options: ShipRevClientOptions);
+    /**
+     * Connects the client: fetches the signing keys, exchanges the API key for a service token, opens
+     * the push stream and waits for its `ready` frame, then loads the full entitlement snapshot. Never
+     * throws: LIVE when all four succeed, DISCONNECTED when only the stream failed, COLD_OFFLINE when
+     * nothing could be loaded. From here until `stop()` the client renews its token, follows the push
+     * stream and reconnects by itself.
+     */
+    start(): Promise<{
+        project_id: string;
+        snapshot_revision: number;
+        state: ClientState;
+    }>;
+    /**
+     * Closes the push stream, stops every timer and flushes buffered usage events.
+     */
+    stop(): Promise<void>;
+    /**
+     * Enqueues a metered usage event into the memory buffer for batched delivery.
+     */
+    reportUsage(event: UsageEventItem): Promise<void>;
+    /**
+     * Manually flushes currently buffered usage events to the core service.
+     */
+    flush(): Promise<void>;
+    /**
+     * Verifies an RS256 JWT token locally and extracts subject and isolation keys.
+     */
+    verifyToken(jwt: string): Promise<TokenClaims>;
+    /**
+     * Executes a four-tier local adjudication (synchronous, zero-IO, P95 <= 5ms).
+     */
+    adjudicate(options: AdjudicateOptions): Ruling;
+    /**
+     * Asynchronous adjudication with authoritative fallback.
+     * If local mirror misses the organization or rule and client is online, queries core service and backfills mirror.
+     */
+    adjudicateAsync(options: AdjudicateOptions): Promise<Ruling>;
+    /**
+     * The effective degradation level of an organization: the level of the mirror entry while the instance
+     * answers; without an answer, the entry's level until its `valid_until`, then at least `RESTRICT_USAGE`
+     * (marked `expired`). `undefined` when the mirror does not hold the organization. Synchronous, no I/O.
+     *
+     * It does not change `adjudicate()` or `guardWrite()`: a disconnected write is refused whatever the level.
+     */
+    effectiveLevel(organizationId: string): EffectiveLevel | undefined;
+    /**
+     * Pulls one organization now (sharing a pull already in flight for it) and resolves with the level of the
+     * answer, `source: 'answer'`. When the pull fails or does not finish within `timeout_ms` (default: the
+     * connect timeout), resolves with `effectiveLevel()` as it stands. `undefined` when the instance no longer
+     * holds the organization, or the mirror never did.
+     */
+    refresh(organizationId: string, options?: {
+        timeout_ms?: number;
+    }): Promise<EffectiveLevel | undefined>;
+    /**
+     * Sends a batch of usage events at once, outside the buffer and the backlog, and resolves with what the
+     * instance did with each. A 401 renews the token once, as every request does. Throws `UsageDeliveryError`
+     * when the batch did not reach the instance or it failed to process it (network error, timeout, 5xx); any
+     * other refusal throws as it came. Sending the same batch again is safe: events are deduplicated by key.
+     */
+    sendUsage(events: UsageSendEvent[]): Promise<UsageSendResult>;
+    /**
+     * Guard for write operations (fail-closed).
+     * Intercepts action if write operation is denied (e.g. disconnected).
+     */
+    guardWrite<T>(options: Omit<AdjudicateOptions, 'operation'>, action: () => Promise<T> | T): Promise<T>;
+    /**
+     * Two-phase entitlement reservation: reserve
+     */
+    reserve(options: ReserveOptions): Promise<ReservationResult>;
+    /**
+     * Two-phase entitlement reservation: confirm. Without `actualAmount` the reserved amount is confirmed.
+     */
+    confirm(reservationId: string, actualAmount?: number): Promise<ConfirmReservationResult>;
+    /**
+     * Two-phase entitlement reservation: release
+     */
+    release(reservationId: string): Promise<ReleaseReservationResult>;
+    /**
+     * Directly loads a snapshot into the local mirror (e.g. for offline seed testing).
+     */
+    loadSnapshot(snapshot: Snapshot): boolean;
+    /**
+     * Returns current internal state and mirror revision.
+     */
+    state(): {
+        state: ClientState;
+        snapshot_revision: number;
+        last_sync_at?: number;
+    };
+    /**
+     * Switches the connection state by hand, for fault injection and tests. `false` closes the push
+     * stream and suspends reconnection until `setOnline(true)`, which sets LIVE at once and resumes
+     * supervision; on a started client the supervisor then corrects the state.
+     */
+    setOnline(online: boolean): void;
+    /**
+     * Sets the machine token by hand (for tests without `start()`); a decodable JWT also sets the
+     * issuer and application `verifyToken()` expects.
+     */
+    setM2MToken(token: string): void;
+    /**
+     * Directly preloads a public key into the token verifier cache (for testing without network).
+     */
+    setPublicKey(kid: string, pem: string): void;
+    getUsageBuffer(): UsageBuffer;
+    getTransport(): HttpTransport;
+    private applyOnline;
+    private onMirrorChange;
+    /** Reports every organization whose effective level differs from what was last reported. */
+    private notifyLevels;
+    /** While disconnected, wakes up when the earliest entry still valid expires, to report it. */
+    private armExpiryTimer;
+    private learnExpectations;
+    private refillOrganization;
+}

package/dist/client/shiprev-client.js

@@ -0,0 +1,400 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShipRevClient = void 0;
+const token_verifier_1 = require("../auth/token-verifier");
+const usage_buffer_1 = require("../metering/usage-buffer");
+const degradation_1 = require("../mirror/degradation");
+const entitlement_mirror_1 = require("../mirror/entitlement-mirror");
+const adjudicator_1 = require("../ruling/adjudicator");
+const http_transport_1 = require("../transport/http.transport");
+const types_1 = require("../types");
+const connection_supervisor_1 = require("./connection-supervisor");
+class ShipRevClient {
+    options;
+    transport;
+    tokenVerifier;
+    mirror;
+    adjudicator;
+    usageBuffer;
+    supervisor;
+    /** COLD until start() or setOnline(); otherwise the state follows the online signal and the mirror. */
+    active = false;
+    isOnline = false;
+    /** Issuer and application expected of session tokens, learned from the machine token. */
+    expectations = null;
+    /** Amounts reserved by this client, so `confirm()` without an amount confirms what was reserved. */
+    reservedAmounts = new Map();
+    /** Effective levels last reported through `on_level_change`. */
+    reportedLevels = new Map();
+    /** Fires when the earliest `valid_until` passes while disconnected, to report the expiry. */
+    expiryTimer = null;
+    constructor(options) {
+        this.options = options;
+        this.transport = new http_transport_1.HttpTransport({
+            baseUrl: options.base_url,
+            connectTimeoutMs: options.presets?.connect_timeout_ms,
+        });
+        this.tokenVerifier = new token_verifier_1.TokenVerifier(this.transport);
+        this.mirror = new entitlement_mirror_1.EntitlementMirror((organizationIds) => this.onMirrorChange(organizationIds));
+        this.adjudicator = new adjudicator_1.Adjudicator(this.mirror, options.presets);
+        this.supervisor = new connection_supervisor_1.ConnectionSupervisor({
+            transport: this.transport,
+            mirror: this.mirror,
+            apiKey: options.api_key,
+            connectTimeoutMs: options.presets?.connect_timeout_ms ?? 5000,
+            loadKeys: () => this.tokenVerifier.refreshKeys(),
+            onToken: (token) => this.learnExpectations(token),
+            setOnline: (online) => this.applyOnline(online),
+            flush: () => this.usageBuffer.flush(),
+        });
+        this.usageBuffer = new usage_buffer_1.UsageBuffer({
+            transport: this.transport,
+            getToken: () => this.supervisor.currentToken(),
+            isOnline: () => this.isOnline,
+            send: (events) => this.supervisor.authorized((token) => this.transport.reportUsageEvents(events, token)),
+            bufferConfig: options.buffer,
+            backlogConfig: options.backlog,
+            onFlushFailure: options.on_flush_failure,
+            onRejected: options.on_rejected,
+        });
+    }
+    /**
+     * Connects the client: fetches the signing keys, exchanges the API key for a service token, opens
+     * the push stream and waits for its `ready` frame, then loads the full entitlement snapshot. Never
+     * throws: LIVE when all four succeed, DISCONNECTED when only the stream failed, COLD_OFFLINE when
+     * nothing could be loaded. From here until `stop()` the client renews its token, follows the push
+     * stream and reconnects by itself.
+     */
+    async start() {
+        this.active = true;
+        await this.supervisor.start();
+        return {
+            project_id: this.mirror.getProjectId(),
+            snapshot_revision: this.mirror.getRevision(),
+            state: this.state().state,
+        };
+    }
+    /**
+     * Closes the push stream, stops every timer and flushes buffered usage events.
+     */
+    async stop() {
+        this.supervisor.stop();
+        if (this.expiryTimer) {
+            clearTimeout(this.expiryTimer);
+            this.expiryTimer = null;
+        }
+        await this.usageBuffer.stop();
+        this.active = false;
+        this.isOnline = false;
+    }
+    /**
+     * Enqueues a metered usage event into the memory buffer for batched delivery.
+     */
+    async reportUsage(event) {
+        if (!Number.isFinite(event.quantity)) {
+            throw new RangeError(`Usage quantity must be a finite number, got ${event.quantity}`);
+        }
+        await this.usageBuffer.reportUsage(event);
+    }
+    /**
+     * Manually flushes currently buffered usage events to the core service.
+     */
+    async flush() {
+        await this.usageBuffer.flush();
+    }
+    /**
+     * Verifies an RS256 JWT token locally and extracts subject and isolation keys.
+     */
+    async verifyToken(jwt) {
+        return this.tokenVerifier.verifyToken(jwt, this.expectations);
+    }
+    /**
+     * Executes a four-tier local adjudication (synchronous, zero-IO, P95 <= 5ms).
+     */
+    adjudicate(options) {
+        return this.adjudicator.adjudicate(options, this.isOnline);
+    }
+    /**
+     * Asynchronous adjudication with authoritative fallback.
+     * If local mirror misses the organization or rule and client is online, queries core service and backfills mirror.
+     */
+    async adjudicateAsync(options) {
+        const ruling = this.adjudicate(options);
+        // If local ruling is already allowed (realtime or degraded read) or degraded write rejection, return directly
+        if (ruling.allowed || ruling.source === 'degraded' || !this.isOnline) {
+            return ruling;
+        }
+        // Two cases are not decided by the mirror, and the service is asked for an authoritative ruling:
+        // the mirror misses the organization or capability, or the write goes beyond the allowance the mirror
+        // counts (credits and overdraft are the service's state). The mirror's refusal stands when no ruling comes.
+        const beyondAllowance = ruling.reason === 'quota_exhausted' && ruling.source === 'realtime';
+        if (this.supervisor.currentToken() && (ruling.reason === 'capability_not_granted' || beyondAllowance)) {
+            try {
+                const remote = await this.supervisor.authorized((token) => this.transport.lookupAdjudication({
+                    organization_id: options.organization_id,
+                    capability_key: options.capability_key,
+                    quantity: options.quantity,
+                    operation: options.operation,
+                }, token));
+                if (remote.allowed) {
+                    await this.refillOrganization(options.organization_id);
+                }
+                return {
+                    allowed: remote.allowed,
+                    remaining: remote.remaining,
+                    limit: remote.limit,
+                    source: 'authoritative',
+                    reason: remote.reason,
+                    adjudicated_at: Date.now(),
+                };
+            }
+            catch {
+                // Fall back to original ruling if remote call fails
+                return ruling;
+            }
+        }
+        return ruling;
+    }
+    /**
+     * The effective degradation level of an organization: the level of the mirror entry while the instance
+     * answers; without an answer, the entry's level until its `valid_until`, then at least `RESTRICT_USAGE`
+     * (marked `expired`). `undefined` when the mirror does not hold the organization. Synchronous, no I/O.
+     *
+     * It does not change `adjudicate()` or `guardWrite()`: a disconnected write is refused whatever the level.
+     */
+    effectiveLevel(organizationId) {
+        const entry = this.mirror.getOrganization(organizationId);
+        return entry ? (0, degradation_1.combineLevel)(entry, this.isOnline, Date.now()) : undefined;
+    }
+    /**
+     * Pulls one organization now (sharing a pull already in flight for it) and resolves with the level of the
+     * answer, `source: 'answer'`. When the pull fails or does not finish within `timeout_ms` (default: the
+     * connect timeout), resolves with `effectiveLevel()` as it stands. `undefined` when the instance no longer
+     * holds the organization, or the mirror never did.
+     */
+    async refresh(organizationId, options) {
+        const timeoutMs = options?.timeout_ms ?? this.options.presets?.connect_timeout_ms ?? 5000;
+        let timer;
+        try {
+            const pulled = await Promise.race([
+                this.supervisor.pullOrganization(organizationId),
+                new Promise((_resolve, reject) => {
+                    timer = setTimeout(() => reject(new Error('refresh timed out')), timeoutMs);
+                    timer.unref();
+                }),
+            ]);
+            // Only an answer the mirror took is an answer; a stale or unsupported one leaves the level as it stands.
+            if (pulled.outcome === 'applied' && pulled.entry)
+                return (0, degradation_1.combineLevel)(pulled.entry, true, Date.now());
+            if (pulled.outcome === 'removed')
+                return undefined;
+            return this.effectiveLevel(organizationId);
+        }
+        catch {
+            return this.effectiveLevel(organizationId);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    /**
+     * Sends a batch of usage events at once, outside the buffer and the backlog, and resolves with what the
+     * instance did with each. A 401 renews the token once, as every request does. Throws `UsageDeliveryError`
+     * when the batch did not reach the instance or it failed to process it (network error, timeout, 5xx); any
+     * other refusal throws as it came. Sending the same batch again is safe: events are deduplicated by key.
+     */
+    async sendUsage(events) {
+        try {
+            return await this.supervisor.authorized((token) => this.transport.sendUsageEvents(events, token));
+        }
+        catch (error) {
+            if (error instanceof http_transport_1.HttpError && error.status < 500)
+                throw error;
+            throw new types_1.UsageDeliveryError(error instanceof Error ? error.message : 'Usage events could not be delivered');
+        }
+    }
+    /**
+     * Guard for write operations (fail-closed).
+     * Intercepts action if write operation is denied (e.g. disconnected).
+     */
+    async guardWrite(options, action) {
+        const ruling = this.adjudicate({ ...options, operation: 'write' });
+        if (!ruling.allowed) {
+            throw new types_1.DisconnectedWriteError(ruling.reason === 'disconnected_write'
+                ? 'Write operation denied while client is disconnected'
+                : `Write operation denied: ${ruling.reason ?? 'not allowed'}`);
+        }
+        return action();
+    }
+    /**
+     * Two-phase entitlement reservation: reserve
+     */
+    async reserve(options) {
+        const ttlSeconds = options.ttl_seconds ?? this.options.presets?.reservation_ttl_s;
+        const result = await this.supervisor.authorized((token) => this.transport.reserve(ttlSeconds !== undefined ? { ...options, ttl_seconds: ttlSeconds } : options, token));
+        this.reservedAmounts.set(result.reservation_id, options.amount);
+        return result;
+    }
+    /**
+     * Two-phase entitlement reservation: confirm. Without `actualAmount` the reserved amount is confirmed.
+     */
+    async confirm(reservationId, actualAmount) {
+        const amount = actualAmount ?? this.reservedAmounts.get(reservationId);
+        if (amount === undefined) {
+            throw new Error(`Reservation '${reservationId}' was not made by this client: pass the actual amount to confirm it`);
+        }
+        const result = await this.supervisor.authorized((token) => this.transport.confirmReservation(reservationId, amount, token));
+        this.reservedAmounts.delete(reservationId);
+        return result;
+    }
+    /**
+     * Two-phase entitlement reservation: release
+     */
+    async release(reservationId) {
+        const result = await this.supervisor.authorized((token) => this.transport.releaseReservation(reservationId, token));
+        this.reservedAmounts.delete(reservationId);
+        return result;
+    }
+    /**
+     * Directly loads a snapshot into the local mirror (e.g. for offline seed testing).
+     */
+    loadSnapshot(snapshot) {
+        return this.mirror.loadSnapshot(snapshot);
+    }
+    /**
+     * Returns current internal state and mirror revision.
+     */
+    state() {
+        const state = !this.active
+            ? 'COLD'
+            : this.isOnline
+                ? 'LIVE'
+                : this.mirror.isEmpty()
+                    ? 'COLD_OFFLINE'
+                    : 'DISCONNECTED';
+        return {
+            state,
+            snapshot_revision: this.mirror.getRevision(),
+            last_sync_at: this.mirror.getLastUpdatedAt() || undefined,
+        };
+    }
+    /**
+     * Switches the connection state by hand, for fault injection and tests. `false` closes the push
+     * stream and suspends reconnection until `setOnline(true)`, which sets LIVE at once and resumes
+     * supervision; on a started client the supervisor then corrects the state.
+     */
+    setOnline(online) {
+        this.active = true;
+        this.applyOnline(online);
+        if (online) {
+            this.supervisor.resume();
+        }
+        else {
+            this.supervisor.pause();
+        }
+    }
+    /**
+     * Sets the machine token by hand (for tests without `start()`); a decodable JWT also sets the
+     * issuer and application `verifyToken()` expects.
+     */
+    setM2MToken(token) {
+        this.supervisor.injectToken(token);
+        this.learnExpectations(token);
+    }
+    /**
+     * Directly preloads a public key into the token verifier cache (for testing without network).
+     */
+    setPublicKey(kid, pem) {
+        this.tokenVerifier.setPublicKey(kid, pem);
+    }
+    getUsageBuffer() {
+        return this.usageBuffer;
+    }
+    getTransport() {
+        return this.transport;
+    }
+    applyOnline(online) {
+        const changed = this.isOnline !== online;
+        this.isOnline = online;
+        if (changed) {
+            this.notifyLevels(this.mirror.organizationIds());
+            this.armExpiryTimer();
+        }
+    }
+    onMirrorChange(organizationIds) {
+        if (organizationIds === null) {
+            // The whole mirror was replaced: organizations that left it are forgotten.
+            for (const organizationId of [...this.reportedLevels.keys()]) {
+                if (!this.mirror.hasOrganization(organizationId))
+                    this.reportedLevels.delete(organizationId);
+            }
+        }
+        this.notifyLevels(organizationIds ?? this.mirror.organizationIds());
+        this.armExpiryTimer();
+        this.supervisor?.scheduleRenewals();
+    }
+    /** Reports every organization whose effective level differs from what was last reported. */
+    notifyLevels(organizationIds) {
+        const listener = this.options.on_level_change;
+        if (!listener)
+            return;
+        for (const organizationId of organizationIds) {
+            const level = this.effectiveLevel(organizationId);
+            if (!level) {
+                this.reportedLevels.delete(organizationId);
+                continue;
+            }
+            if ((0, degradation_1.sameLevel)(level, this.reportedLevels.get(organizationId)))
+                continue;
+            this.reportedLevels.set(organizationId, level);
+            try {
+                listener(organizationId, level);
+            }
+            catch {
+                // A listener failure never reaches the connection.
+            }
+        }
+    }
+    /** While disconnected, wakes up when the earliest entry still valid expires, to report it. */
+    armExpiryTimer() {
+        if (this.expiryTimer) {
+            clearTimeout(this.expiryTimer);
+            this.expiryTimer = null;
+        }
+        if (!this.options.on_level_change || this.isOnline || !this.active)
+            return;
+        const now = Date.now();
+        let next = Number.POSITIVE_INFINITY;
+        for (const organizationId of this.mirror.organizationIds()) {
+            const validUntil = (0, degradation_1.validUntilOf)(this.mirror.getOrganization(organizationId));
+            if (validUntil !== undefined && validUntil > now)
+                next = Math.min(next, validUntil);
+        }
+        if (next === Number.POSITIVE_INFINITY)
+            return;
+        this.expiryTimer = setTimeout(() => {
+            this.expiryTimer = null;
+            this.notifyLevels(this.mirror.organizationIds());
+            this.armExpiryTimer();
+        }, next - now);
+        this.expiryTimer.unref();
+    }
+    learnExpectations(token) {
+        const expectations = (0, token_verifier_1.expectationsFromMachineToken)(token);
+        if (expectations) {
+            this.expectations = expectations;
+        }
+    }
+    async refillOrganization(organizationId) {
+        try {
+            const snapshot = await this.supervisor.authorized((token) => this.transport.fetchSnapshot(token, organizationId));
+            this.mirror.mergeSnapshot(snapshot);
+        }
+        catch {
+            // The authoritative ruling stands; the next full sync fills the mirror.
+        }
+    }
+}
+exports.ShipRevClient = ShipRevClient;
+//# sourceMappingURL=shiprev-client.js.map

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { ShipRevClient } from './client/shiprev-client';
+import { ShipRevClientOptions } from './types';
+export { jwkToPem, TokenVerifier } from './auth/token-verifier';
+export { ShipRevClient } from './client/shiprev-client';
+export { HostAdapterBacklog } from './metering/backlog/host-adapter-backlog';
+export { JournalBacklog } from './metering/backlog/journal-backlog';
+export { MemoryBacklog } from './metering/backlog/memory-backlog';
+export { UsageBuffer } from './metering/usage-buffer';
+export { EntitlementMirror, MAX_SUPPORTED_SCHEMA_VERSION } from './mirror/entitlement-mirror';
+export { Adjudicator } from './ruling/adjudicator';
+export { HttpTransport } from './transport/http.transport';
+export * from './types';
+/**
+ * Creates and initializes a ShipRev Server SDK client instance for Node.js services.
+ */
+export declare function createClient(options: ShipRevClientOptions): ShipRevClient;

package/dist/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpTransport = exports.Adjudicator = exports.MAX_SUPPORTED_SCHEMA_VERSION = exports.EntitlementMirror = exports.UsageBuffer = exports.MemoryBacklog = exports.JournalBacklog = exports.HostAdapterBacklog = exports.ShipRevClient = exports.TokenVerifier = exports.jwkToPem = void 0;
+exports.createClient = createClient;
+const shiprev_client_1 = require("./client/shiprev-client");
+var token_verifier_1 = require("./auth/token-verifier");
+Object.defineProperty(exports, "jwkToPem", { enumerable: true, get: function () { return token_verifier_1.jwkToPem; } });
+Object.defineProperty(exports, "TokenVerifier", { enumerable: true, get: function () { return token_verifier_1.TokenVerifier; } });
+var shiprev_client_2 = require("./client/shiprev-client");
+Object.defineProperty(exports, "ShipRevClient", { enumerable: true, get: function () { return shiprev_client_2.ShipRevClient; } });
+var host_adapter_backlog_1 = require("./metering/backlog/host-adapter-backlog");
+Object.defineProperty(exports, "HostAdapterBacklog", { enumerable: true, get: function () { return host_adapter_backlog_1.HostAdapterBacklog; } });
+var journal_backlog_1 = require("./metering/backlog/journal-backlog");
+Object.defineProperty(exports, "JournalBacklog", { enumerable: true, get: function () { return journal_backlog_1.JournalBacklog; } });
+var memory_backlog_1 = require("./metering/backlog/memory-backlog");
+Object.defineProperty(exports, "MemoryBacklog", { enumerable: true, get: function () { return memory_backlog_1.MemoryBacklog; } });
+var usage_buffer_1 = require("./metering/usage-buffer");
+Object.defineProperty(exports, "UsageBuffer", { enumerable: true, get: function () { return usage_buffer_1.UsageBuffer; } });
+var entitlement_mirror_1 = require("./mirror/entitlement-mirror");
+Object.defineProperty(exports, "EntitlementMirror", { enumerable: true, get: function () { return entitlement_mirror_1.EntitlementMirror; } });
+Object.defineProperty(exports, "MAX_SUPPORTED_SCHEMA_VERSION", { enumerable: true, get: function () { return entitlement_mirror_1.MAX_SUPPORTED_SCHEMA_VERSION; } });
+var adjudicator_1 = require("./ruling/adjudicator");
+Object.defineProperty(exports, "Adjudicator", { enumerable: true, get: function () { return adjudicator_1.Adjudicator; } });
+var http_transport_1 = require("./transport/http.transport");
+Object.defineProperty(exports, "HttpTransport", { enumerable: true, get: function () { return http_transport_1.HttpTransport; } });
+__exportStar(require("./types"), exports);
+/**
+ * Creates and initializes a ShipRev Server SDK client instance for Node.js services.
+ */
+function createClient(options) {
+    return new shiprev_client_1.ShipRevClient(options);
+}
+//# sourceMappingURL=index.js.map

package/dist/metering/backlog/host-adapter-backlog.d.ts

@@ -0,0 +1,10 @@
+import { BacklogAdapter, BacklogItem, UsageEventItem } from '../../types';
+export declare class HostAdapterBacklog implements BacklogAdapter {
+    private readonly adapter;
+    constructor(customAdapter?: BacklogAdapter);
+    enqueue(event: UsageEventItem): Promise<void>;
+    peek(limit: number): Promise<BacklogItem[]>;
+    ack(ids: string[]): Promise<void>;
+    nack(ids: string[]): Promise<void>;
+    size(): Promise<number>;
+}

package/dist/metering/backlog/host-adapter-backlog.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostAdapterBacklog = void 0;
+const memory_backlog_1 = require("./memory-backlog");
+class HostAdapterBacklog {
+    adapter;
+    constructor(customAdapter) {
+        this.adapter = customAdapter ?? new memory_backlog_1.MemoryBacklog();
+    }
+    async enqueue(event) {
+        return this.adapter.enqueue(event);
+    }
+    async peek(limit) {
+        return this.adapter.peek(limit);
+    }
+    async ack(ids) {
+        return this.adapter.ack(ids);
+    }
+    async nack(ids) {
+        return this.adapter.nack(ids);
+    }
+    async size() {
+        return this.adapter.size();
+    }
+}
+exports.HostAdapterBacklog = HostAdapterBacklog;
+//# sourceMappingURL=host-adapter-backlog.js.map

package/dist/metering/backlog/journal-backlog.d.ts

@@ -0,0 +1,14 @@
+import { BacklogAdapter, BacklogItem, UsageEventItem } from '../../types';
+export declare class JournalBacklog implements BacklogAdapter {
+    private readonly filePath;
+    private queue;
+    private isCompacting;
+    constructor(filePath?: string);
+    private recoverSync;
+    enqueue(event: UsageEventItem): Promise<void>;
+    peek(limit: number): Promise<BacklogItem[]>;
+    ack(ids: string[]): Promise<void>;
+    nack(ids: string[]): Promise<void>;
+    size(): Promise<number>;
+    private compact;
+}