velocious 1.0.430 → 1.0.431

package/build/src/http-server/server-lock.js

@@ -1,164 +1,178 @@
 // @ts-check
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
+
+import fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+
 /**
  * Directory-based lock that allows only one HTTP server process per app directory.
  */
 export default class VelociousHttpServerLock {
-    /**
-     * Build a lock for the configured application directory and server endpoint.
-     * @param {object} args - Options object.
-     * @param {import("../configuration.js").default} args.configuration - Configuration that owns the application directory.
-     * @param {string} args.host - Configured HTTP host.
-     * @param {number} args.port - Configured HTTP port.
-     */
-    constructor({ configuration, host, port }) {
-        this.configuration = configuration;
-        this.host = host;
-        this.port = port;
-        this.lockPath = path.join(configuration.getDirectory(), "tmp", "server.lock");
-        this.acquired = false;
+  /**
+   * Build a lock for the configured application directory and server endpoint.
+   * @param {object} args - Options object.
+   * @param {import("../configuration.js").default} args.configuration - Configuration that owns the application directory.
+   * @param {string} args.host - Configured HTTP host.
+   * @param {number} args.port - Configured HTTP port.
+   */
+  constructor({configuration, host, port}) {
+    this.configuration = configuration
+    this.host = host
+    this.port = port
+    this.lockPath = path.join(configuration.getDirectory(), "tmp", "server.lock")
+    this.acquired = false
+  }
+
+  /**
+   * Acquires the app-directory HTTP server lock before startup side effects run.
+   * @returns {Promise<void>} - Resolves after the lock has been acquired.
+   */
+  async acquire() {
+    await fs.mkdir(path.dirname(this.lockPath), {recursive: true})
+
+    while (true) {
+      const acquired = await this.tryAcquire()
+
+      if (acquired) {
+        return
+      }
+
+      if (await this.isStale()) {
+        await fs.rm(this.lockPath, {recursive: true, force: true})
+        continue
+      }
+
+      throw new Error(await this.lockHeldMessage())
     }
-    /**
-     * Acquires the app-directory HTTP server lock before startup side effects run.
-     * @returns {Promise<void>} - Resolves after the lock has been acquired.
-     */
-    async acquire() {
-        await fs.mkdir(path.dirname(this.lockPath), { recursive: true });
-        while (true) {
-            const acquired = await this.tryAcquire();
-            if (acquired) {
-                return;
-            }
-            if (await this.isStale()) {
-                await fs.rm(this.lockPath, { recursive: true, force: true });
-                continue;
-            }
-            throw new Error(await this.lockHeldMessage());
-        }
+  }
+
+  /**
+   * Tries to create the lock directory and write owner metadata.
+   * @returns {Promise<boolean>} - Whether the lock was acquired.
+   */
+  async tryAcquire() {
+    try {
+      await fs.mkdir(this.lockPath)
+    } catch (error) {
+      if (/**
+           * Narrows the runtime value to the documented type.
+            @type {{code?: string}} */ (error).code === "EEXIST") return false
+      throw error
     }
-    /**
-     * Tries to create the lock directory and write owner metadata.
-     * @returns {Promise<boolean>} - Whether the lock was acquired.
-     */
-    async tryAcquire() {
-        try {
-            await fs.mkdir(this.lockPath);
-        }
-        catch (error) {
-            if ( /**
-                 * Narrows the runtime value to the documented type.
-                  @type {{code?: string}} */(error).code === "EEXIST")
-                return false;
-            throw error;
-        }
-        try {
-            await this.writeOwnerMetadata();
-            this.acquired = true;
-            return true;
-        }
-        catch (error) {
-            await fs.rm(this.lockPath, { recursive: true, force: true });
-            throw error;
-        }
+
+    try {
+      await this.writeOwnerMetadata()
+      this.acquired = true
+
+      return true
+    } catch (error) {
+      await fs.rm(this.lockPath, {recursive: true, force: true})
+      throw error
     }
-    /**
-     * Releases the held HTTP server lock directory.
-     * @returns {Promise<void>} - Resolves after best-effort lock release.
-     */
-    async release() {
-        if (!this.acquired)
-            return;
-        this.acquired = false;
-        await fs.rm(this.lockPath, { recursive: true, force: true });
+  }
+
+  /**
+   * Releases the held HTTP server lock directory.
+   * @returns {Promise<void>} - Resolves after best-effort lock release.
+   */
+  async release() {
+    if (!this.acquired) return
+
+    this.acquired = false
+    await fs.rm(this.lockPath, {recursive: true, force: true})
+  }
+
+  /**
+   * Writes metadata used to explain or reclaim an existing server lock.
+   * @returns {Promise<void>} - Resolves after owner metadata has been written.
+   */
+  async writeOwnerMetadata() {
+    await fs.writeFile(path.join(this.lockPath, "owner.json"), JSON.stringify({
+      acquiredAt: new Date().toISOString(),
+      host: this.host,
+      hostname: os.hostname(),
+      pid: process.pid,
+      port: this.port
+    }))
+  }
+
+  /**
+   * Checks whether the current lock owner is a dead process on this host.
+   * @returns {Promise<boolean>} - Whether the existing lock belongs to a dead process.
+   */
+  async isStale() {
+    const owner = await this.readOwnerMetadata()
+
+    if (!this.isLocalProcessOwner(owner)) return false
+
+    return this.processIsDead(/**
+                               * Narrows the runtime value to the documented type.
+                                @type {{pid: number}} */ (owner).pid)
+  }
+
+  /**
+   * Runs is local process owner.
+   * @param {Record<string, ?> | null} owner - Existing lock owner metadata.
+   * @returns {boolean} - Whether owner metadata names a local process.
+   */
+  isLocalProcessOwner(owner) {
+    if (!owner) return false
+    if (typeof owner.pid !== "number") return false
+
+    return this.ownerHostnameMatches(owner)
+  }
+
+  /**
+   * Runs owner hostname matches.
+   * @param {Record<string, ?>} owner - Existing lock owner metadata.
+   * @returns {boolean} - Whether the owner hostname is local or absent.
+   */
+  ownerHostnameMatches(owner) {
+    if (!owner.hostname) return true
+    if (owner.hostname === os.hostname()) return true
+
+    return false
+  }
+
+  /**
+   * Runs process is dead.
+   * @param {number} pid - Process id.
+   * @returns {boolean} - Whether the process no longer exists.
+   */
+  processIsDead(pid) {
+    try {
+      process.kill(pid, 0)
+
+      return false
+    } catch (error) {
+      return /** Narrows the runtime value to the documented type. @type {{code?: string}} */ (error).code === "ESRCH"
     }
-    /**
-     * Writes metadata used to explain or reclaim an existing server lock.
-     * @returns {Promise<void>} - Resolves after owner metadata has been written.
-     */
-    async writeOwnerMetadata() {
-        await fs.writeFile(path.join(this.lockPath, "owner.json"), JSON.stringify({
-            acquiredAt: new Date().toISOString(),
-            host: this.host,
-            hostname: os.hostname(),
-            pid: process.pid,
-            port: this.port
-        }));
-    }
-    /**
-     * Checks whether the current lock owner is a dead process on this host.
-     * @returns {Promise<boolean>} - Whether the existing lock belongs to a dead process.
-     */
-    async isStale() {
-        const owner = await this.readOwnerMetadata();
-        if (!this.isLocalProcessOwner(owner))
-            return false;
-        return this.processIsDead(/**
-                                   * Narrows the runtime value to the documented type.
-                                    @type {{pid: number}} */ (owner).pid);
-    }
-    /**
-     * Runs is local process owner.
-     * @param {Record<string, ?> | null} owner - Existing lock owner metadata.
-     * @returns {boolean} - Whether owner metadata names a local process.
-     */
-    isLocalProcessOwner(owner) {
-        if (!owner)
-            return false;
-        if (typeof owner.pid !== "number")
-            return false;
-        return this.ownerHostnameMatches(owner);
-    }
-    /**
-     * Runs owner hostname matches.
-     * @param {Record<string, ?>} owner - Existing lock owner metadata.
-     * @returns {boolean} - Whether the owner hostname is local or absent.
-     */
-    ownerHostnameMatches(owner) {
-        if (!owner.hostname)
-            return true;
-        if (owner.hostname === os.hostname())
-            return true;
-        return false;
-    }
-    /**
-     * Runs process is dead.
-     * @param {number} pid - Process id.
-     * @returns {boolean} - Whether the process no longer exists.
-     */
-    processIsDead(pid) {
-        try {
-            process.kill(pid, 0);
-            return false;
-        }
-        catch (error) {
-            return /** Narrows the runtime value to the documented type. @type {{code?: string}} */ (error).code === "ESRCH";
-        }
-    }
-    /**
-     * Reads owner metadata from an existing server lock directory.
-     * @returns {Promise<Record<string, ?> | null>} - Parsed owner metadata, when readable.
-     */
-    async readOwnerMetadata() {
-        try {
-            const rawOwner = await fs.readFile(path.join(this.lockPath, "owner.json"), "utf8");
-            return /** Narrows the runtime value to the documented type. @type {Record<string, ?>} */ (JSON.parse(rawOwner));
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Builds a duplicate-server error message with owner details when available.
-     * @returns {Promise<string>} - Error message explaining which server owns the lock.
-     */
-    async lockHeldMessage() {
-        const owner = await this.readOwnerMetadata();
-        const details = owner
-            ? `PID ${String(owner.pid)} on ${String(owner.hostname)} (${String(owner.host)}:${String(owner.port)})`
-            : `lock directory ${this.lockPath}`;
-        return `A Velocious HTTP server is already running for this application (${details}). Remove ${this.lockPath} if the server is no longer running.`;
+  }
+
+  /**
+   * Reads owner metadata from an existing server lock directory.
+   * @returns {Promise<Record<string, ?> | null>} - Parsed owner metadata, when readable.
+   */
+  async readOwnerMetadata() {
+    try {
+      const rawOwner = await fs.readFile(path.join(this.lockPath, "owner.json"), "utf8")
+
+      return /** Narrows the runtime value to the documented type. @type {Record<string, ?>} */ (JSON.parse(rawOwner))
+    } catch {
+      return null
     }
+  }
+
+  /**
+   * Builds a duplicate-server error message with owner details when available.
+   * @returns {Promise<string>} - Error message explaining which server owns the lock.
+   */
+  async lockHeldMessage() {
+    const owner = await this.readOwnerMetadata()
+    const details = owner
+      ? `PID ${String(owner.pid)} on ${String(owner.hostname)} (${String(owner.host)}:${String(owner.port)})`
+      : `lock directory ${this.lockPath}`
+
+    return `A Velocious HTTP server is already running for this application (${details}). Remove ${this.lockPath} if the server is no longer running.`
+  }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server-lock.js","sourceRoot":"","sources":["../../../src/http-server/server-lock.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport fs from \"node:fs/promises\"\nimport os from \"node:os\"\nimport path from \"node:path\"\n\n/**\n * Directory-based lock that allows only one HTTP server process per app directory.\n */\nexport default class VelociousHttpServerLock {\n  /**\n   * Build a lock for the configured application directory and server endpoint.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration that owns the application directory.\n   * @param {string} args.host - Configured HTTP host.\n   * @param {number} args.port - Configured HTTP port.\n   */\n  constructor({configuration, host, port}) {\n    this.configuration = configuration\n    this.host = host\n    this.port = port\n    this.lockPath = path.join(configuration.getDirectory(), \"tmp\", \"server.lock\")\n    this.acquired = false\n  }\n\n  /**\n   * Acquires the app-directory HTTP server lock before startup side effects run.\n   * @returns {Promise<void>} - Resolves after the lock has been acquired.\n   */\n  async acquire() {\n    await fs.mkdir(path.dirname(this.lockPath), {recursive: true})\n\n    while (true) {\n      const acquired = await this.tryAcquire()\n\n      if (acquired) {\n        return\n      }\n\n      if (await this.isStale()) {\n        await fs.rm(this.lockPath, {recursive: true, force: true})\n        continue\n      }\n\n      throw new Error(await this.lockHeldMessage())\n    }\n  }\n\n  /**\n   * Tries to create the lock directory and write owner metadata.\n   * @returns {Promise<boolean>} - Whether the lock was acquired.\n   */\n  async tryAcquire() {\n    try {\n      await fs.mkdir(this.lockPath)\n    } catch (error) {\n      if (/**\n           * Narrows the runtime value to the documented type.\n            @type {{code?: string}} */ (error).code === \"EEXIST\") return false\n      throw error\n    }\n\n    try {\n      await this.writeOwnerMetadata()\n      this.acquired = true\n\n      return true\n    } catch (error) {\n      await fs.rm(this.lockPath, {recursive: true, force: true})\n      throw error\n    }\n  }\n\n  /**\n   * Releases the held HTTP server lock directory.\n   * @returns {Promise<void>} - Resolves after best-effort lock release.\n   */\n  async release() {\n    if (!this.acquired) return\n\n    this.acquired = false\n    await fs.rm(this.lockPath, {recursive: true, force: true})\n  }\n\n  /**\n   * Writes metadata used to explain or reclaim an existing server lock.\n   * @returns {Promise<void>} - Resolves after owner metadata has been written.\n   */\n  async writeOwnerMetadata() {\n    await fs.writeFile(path.join(this.lockPath, \"owner.json\"), JSON.stringify({\n      acquiredAt: new Date().toISOString(),\n      host: this.host,\n      hostname: os.hostname(),\n      pid: process.pid,\n      port: this.port\n    }))\n  }\n\n  /**\n   * Checks whether the current lock owner is a dead process on this host.\n   * @returns {Promise<boolean>} - Whether the existing lock belongs to a dead process.\n   */\n  async isStale() {\n    const owner = await this.readOwnerMetadata()\n\n    if (!this.isLocalProcessOwner(owner)) return false\n\n    return this.processIsDead(/**\n                               * Narrows the runtime value to the documented type.\n                                @type {{pid: number}} */ (owner).pid)\n  }\n\n  /**\n   * Runs is local process owner.\n   * @param {Record<string, ?> | null} owner - Existing lock owner metadata.\n   * @returns {boolean} - Whether owner metadata names a local process.\n   */\n  isLocalProcessOwner(owner) {\n    if (!owner) return false\n    if (typeof owner.pid !== \"number\") return false\n\n    return this.ownerHostnameMatches(owner)\n  }\n\n  /**\n   * Runs owner hostname matches.\n   * @param {Record<string, ?>} owner - Existing lock owner metadata.\n   * @returns {boolean} - Whether the owner hostname is local or absent.\n   */\n  ownerHostnameMatches(owner) {\n    if (!owner.hostname) return true\n    if (owner.hostname === os.hostname()) return true\n\n    return false\n  }\n\n  /**\n   * Runs process is dead.\n   * @param {number} pid - Process id.\n   * @returns {boolean} - Whether the process no longer exists.\n   */\n  processIsDead(pid) {\n    try {\n      process.kill(pid, 0)\n\n      return false\n    } catch (error) {\n      return /** Narrows the runtime value to the documented type. @type {{code?: string}} */ (error).code === \"ESRCH\"\n    }\n  }\n\n  /**\n   * Reads owner metadata from an existing server lock directory.\n   * @returns {Promise<Record<string, ?> | null>} - Parsed owner metadata, when readable.\n   */\n  async readOwnerMetadata() {\n    try {\n      const rawOwner = await fs.readFile(path.join(this.lockPath, \"owner.json\"), \"utf8\")\n\n      return /** Narrows the runtime value to the documented type. @type {Record<string, ?>} */ (JSON.parse(rawOwner))\n    } catch {\n      return null\n    }\n  }\n\n  /**\n   * Builds a duplicate-server error message with owner details when available.\n   * @returns {Promise<string>} - Error message explaining which server owns the lock.\n   */\n  async lockHeldMessage() {\n    const owner = await this.readOwnerMetadata()\n    const details = owner\n      ? `PID ${String(owner.pid)} on ${String(owner.hostname)} (${String(owner.host)}:${String(owner.port)})`\n      : `lock directory ${this.lockPath}`\n\n    return `A Velocious HTTP server is already running for this application (${details}). Remove ${this.lockPath} if the server is no longer running.`\n  }\n}\n"]}

package/build/src/http-server/websocket-channel-subscribers.js

@@ -1,4 +1,5 @@
 // @ts-check
+
 /**
  * Per-process registry of channel subscribers used by worker code that
  * needs to react to events broadcast via `websocketEventsHost.publish(...)`
@@ -9,90 +10,101 @@
  * `setWebsocketChannelSubscribers(...)`.
  */
 export default class VelociousWebsocketChannelSubscribers {
-    constructor() {
-        /**
-         * Narrows the runtime value to the documented type.
-          @type {Map<string, Set<(payload: ?, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>>>} */
-        this._subscribers = new Map();
-    }
+  constructor() {
     /**
-     * Runs subscribe.
-     * @param {string} channel - Channel name to subscribe to.
-     * @param {(payload: ?, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>} callback - Callback invoked for each event on the channel.
-     * @returns {() => void} - Unsubscribe function.
-     */
-    subscribe(channel, callback) {
-        if (!channel)
-            throw new Error("channel is required");
-        if (typeof callback !== "function")
-            throw new Error("callback must be a function");
-        let set = this._subscribers.get(channel);
-        if (!set) {
-            set = new Set();
-            this._subscribers.set(channel, set);
-        }
-        set.add(callback);
-        return () => this.unsubscribe(channel, callback);
+     * Narrows the runtime value to the documented type.
+      @type {Map<string, Set<(payload: ?, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>>>} */
+    this._subscribers = new Map()
+  }
+
+  /**
+   * Runs subscribe.
+   * @param {string} channel - Channel name to subscribe to.
+   * @param {(payload: ?, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>} callback - Callback invoked for each event on the channel.
+   * @returns {() => void} - Unsubscribe function.
+   */
+  subscribe(channel, callback) {
+    if (!channel) throw new Error("channel is required")
+    if (typeof callback !== "function") throw new Error("callback must be a function")
+
+    let set = this._subscribers.get(channel)
+
+    if (!set) {
+      set = new Set()
+      this._subscribers.set(channel, set)
     }
-    /**
-     * Runs unsubscribe.
-     * @param {string} channel - Channel name.
-     * @param {(payload: ?, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>} callback - Previously registered callback.
-     * @returns {void}
-     */
-    unsubscribe(channel, callback) {
-        const set = this._subscribers.get(channel);
-        if (!set)
-            return;
-        set.delete(callback);
-        if (set.size === 0) {
-            this._subscribers.delete(channel);
-        }
+
+    set.add(callback)
+
+    return () => this.unsubscribe(channel, callback)
+  }
+
+  /**
+   * Runs unsubscribe.
+   * @param {string} channel - Channel name.
+   * @param {(payload: ?, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>} callback - Previously registered callback.
+   * @returns {void}
+   */
+  unsubscribe(channel, callback) {
+    const set = this._subscribers.get(channel)
+
+    if (!set) return
+
+    set.delete(callback)
+
+    if (set.size === 0) {
+      this._subscribers.delete(channel)
     }
-    /**
-     * Runs has subscribers.
-     * @param {string} channel - Channel name.
-     * @returns {boolean} - Whether any subscribers exist for the channel.
-     */
-    hasSubscribers(channel) {
-        const set = this._subscribers.get(channel);
-        return Boolean(set && set.size > 0);
-    }
-    /**
-     * Dispatch an event to all subscribers of the channel.
-     * @param {object} args - Event args.
-     * @param {string} args.channel - Channel name.
-     * @param {?} args.payload - Event payload.
-     * @param {string} [args.createdAt] - Event creation time.
-     * @param {string} [args.eventId] - Event identifier.
-     * @returns {Promise<void>} - Resolves when all subscribers have completed.
-     */
-    async dispatch({ channel, payload, createdAt, eventId }) {
-        const set = this._subscribers.get(channel);
-        if (!set || set.size === 0)
-            return;
-        // Snapshot the subscribers so callbacks that unsubscribe (themselves or
-        // others) during dispatch do not skip later deliveries for this event.
-        const callbacks = Array.from(set);
-        const meta = { channel, createdAt, eventId };
-        const tasks = [];
-        for (const callback of callbacks) {
-            try {
-                const result = callback(payload, meta);
-                if (result && typeof ( /**
-                                       * Narrows the runtime value to the documented type.
-                                        @type {Promise<void>} */(result)).then === "function") {
-                    tasks.push(/**
-                                * Narrows the runtime value to the documented type.
-                                 @type {Promise<void>} */ (result));
-                }
-            }
-            catch (error) {
-                // Don't let one subscriber's failure abort the others; surface via the returned promises instead.
-                tasks.push(Promise.reject(error));
-            }
+  }
+
+  /**
+   * Runs has subscribers.
+   * @param {string} channel - Channel name.
+   * @returns {boolean} - Whether any subscribers exist for the channel.
+   */
+  hasSubscribers(channel) {
+    const set = this._subscribers.get(channel)
+
+    return Boolean(set && set.size > 0)
+  }
+
+  /**
+   * Dispatch an event to all subscribers of the channel.
+   * @param {object} args - Event args.
+   * @param {string} args.channel - Channel name.
+   * @param {?} args.payload - Event payload.
+   * @param {string} [args.createdAt] - Event creation time.
+   * @param {string} [args.eventId] - Event identifier.
+   * @returns {Promise<void>} - Resolves when all subscribers have completed.
+   */
+  async dispatch({channel, payload, createdAt, eventId}) {
+    const set = this._subscribers.get(channel)
+
+    if (!set || set.size === 0) return
+
+    // Snapshot the subscribers so callbacks that unsubscribe (themselves or
+    // others) during dispatch do not skip later deliveries for this event.
+    const callbacks = Array.from(set)
+    const meta = {channel, createdAt, eventId}
+    const tasks = []
+
+    for (const callback of callbacks) {
+      try {
+        const result = callback(payload, meta)
+
+        if (result && typeof (/**
+                               * Narrows the runtime value to the documented type.
+                                @type {Promise<void>} */ (result)).then === "function") {
+          tasks.push(/**
+                      * Narrows the runtime value to the documented type.
+                       @type {Promise<void>} */ (result))
         }
-        await Promise.all(tasks);
+      } catch (error) {
+        // Don't let one subscriber's failure abort the others; surface via the returned promises instead.
+        tasks.push(Promise.reject(error))
+      }
     }
+
+    await Promise.all(tasks)
+  }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2Vic29ja2V0LWNoYW5uZWwtc3Vic2NyaWJlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaHR0cC1zZXJ2ZXIvd2Vic29ja2V0LWNoYW5uZWwtc3Vic2NyaWJlcnMuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaOzs7Ozs7OztHQVFHO0FBQ0gsTUFBTSxDQUFDLE9BQU8sT0FBTyxvQ0FBb0M7SUFDdkQ7UUFDRTs7MElBRWtJO1FBQ2xJLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxHQUFHLEVBQUUsQ0FBQTtJQUMvQixDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSCxTQUFTLENBQUMsT0FBTyxFQUFFLFFBQVE7UUFDekIsSUFBSSxDQUFDLE9BQU87WUFBRSxNQUFNLElBQUksS0FBSyxDQUFDLHFCQUFxQixDQUFDLENBQUE7UUFDcEQsSUFBSSxPQUFPLFFBQVEsS0FBSyxVQUFVO1lBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyw2QkFBNkIsQ0FBQyxDQUFBO1FBRWxGLElBQUksR0FBRyxHQUFHLElBQUksQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFBO1FBRXhDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUNULEdBQUcsR0FBRyxJQUFJLEdBQUcsRUFBRSxDQUFBO1lBQ2YsSUFBSSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsT0FBTyxFQUFFLEdBQUcsQ0FBQyxDQUFBO1FBQ3JDLENBQUM7UUFFRCxHQUFHLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFBO1FBRWpCLE9BQU8sR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLENBQUE7SUFDbEQsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0gsV0FBVyxDQUFDLE9BQU8sRUFBRSxRQUFRO1FBQzNCLE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFBO1FBRTFDLElBQUksQ0FBQyxHQUFHO1lBQUUsT0FBTTtRQUVoQixHQUFHLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFBO1FBRXBCLElBQUksR0FBRyxDQUFDLElBQUksS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUNuQixJQUFJLENBQUMsWUFBWSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQTtRQUNuQyxDQUFDO0lBQ0gsQ0FBQztJQUVEOzs7O09BSUc7SUFDSCxjQUFjLENBQUMsT0FBTztRQUNwQixNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQTtRQUUxQyxPQUFPLE9BQU8sQ0FBQyxHQUFHLElBQUksR0FBRyxDQUFDLElBQUksR0FBRyxDQUFDLENBQUMsQ0FBQTtJQUNyQyxDQUFDO0lBRUQ7Ozs7Ozs7O09BUUc7SUFDSCxLQUFLLENBQUMsUUFBUSxDQUFDLEVBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFDO1FBQ25ELE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFBO1FBRTFDLElBQUksQ0FBQyxHQUFHLElBQUksR0FBRyxDQUFDLElBQUksS0FBSyxDQUFDO1lBQUUsT0FBTTtRQUVsQyx3RUFBd0U7UUFDeEUsdUVBQXVFO1FBQ3ZFLE1BQU0sU0FBUyxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUE7UUFDakMsTUFBTSxJQUFJLEdBQUcsRUFBQyxPQUFPLEVBQUUsU0FBUyxFQUFFLE9BQU8sRUFBQyxDQUFBO1FBQzFDLE1BQU0sS0FBSyxHQUFHLEVBQUUsQ0FBQTtRQUVoQixLQUFLLE1BQU0sUUFBUSxJQUFJLFNBQVMsRUFBRSxDQUFDO1lBQ2pDLElBQUksQ0FBQztnQkFDSCxNQUFNLE1BQU0sR0FBRyxRQUFRLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQyxDQUFBO2dCQUV0QyxJQUFJLE1BQU0sSUFBSSxPQUFPLEVBQUM7O2dFQUUyQixDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsSUFBSSxLQUFLLFVBQVUsRUFBRSxDQUFDO29CQUMvRSxLQUFLLENBQUMsSUFBSSxDQUFDOzt5REFFMEIsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUE7Z0JBQ2pELENBQUM7WUFDSCxDQUFDO1lBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztnQkFDZixrR0FBa0c7Z0JBQ2xHLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFBO1lBQ25DLENBQUM7UUFDSCxDQUFDO1FBRUQsTUFBTSxPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFBO0lBQzFCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuXG4vKipcbiAqIFBlci1wcm9jZXNzIHJlZ2lzdHJ5IG9mIGNoYW5uZWwgc3Vic2NyaWJlcnMgdXNlZCBieSB3b3JrZXIgY29kZSB0aGF0XG4gKiBuZWVkcyB0byByZWFjdCB0byBldmVudHMgYnJvYWRjYXN0IHZpYSBgd2Vic29ja2V0RXZlbnRzSG9zdC5wdWJsaXNoKC4uLilgXG4gKiB3aXRob3V0IGhvbGRpbmcgYW4gYWN0dWFsIHdlYnNvY2tldCBzZXNzaW9uLlxuICpcbiAqIEVhY2ggVmVsb2Npb3VzIHdvcmtlciB0aHJlYWQgKGFuZCB0aGUgaW4tcHJvY2VzcyBoYW5kbGVyIHVzZWQgaW4gdGVzdHMpXG4gKiBnZXRzIGl0cyBvd24gaW5zdGFuY2UgYXR0YWNoZWQgdG8gdGhlIGNvbmZpZ3VyYXRpb24gdmlhXG4gKiBgc2V0V2Vic29ja2V0Q2hhbm5lbFN1YnNjcmliZXJzKC4uLilgLlxuICovXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBWZWxvY2lvdXNXZWJzb2NrZXRDaGFubmVsU3Vic2NyaWJlcnMge1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICAvKipcbiAgICAgKiBOYXJyb3dzIHRoZSBydW50aW1lIHZhbHVlIHRvIHRoZSBkb2N1bWVudGVkIHR5cGUuXG4gICAgICBAdHlwZSB7TWFwPHN0cmluZywgU2V0PChwYXlsb2FkOiA/LCBtZXRhOiB7Y2hhbm5lbDogc3RyaW5nLCBjcmVhdGVkQXQ/OiBzdHJpbmcsIGV2ZW50SWQ/OiBzdHJpbmd9KSA9PiB2b2lkIHwgUHJvbWlzZTx2b2lkPj4+fSAqL1xuICAgIHRoaXMuX3N1YnNjcmliZXJzID0gbmV3IE1hcCgpXG4gIH1cblxuICAvKipcbiAgICogUnVucyBzdWJzY3JpYmUuXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBjaGFubmVsIC0gQ2hhbm5lbCBuYW1lIHRvIHN1YnNjcmliZSB0by5cbiAgICogQHBhcmFtIHsocGF5bG9hZDogPywgbWV0YToge2NoYW5uZWw6IHN0cmluZywgY3JlYXRlZEF0Pzogc3RyaW5nLCBldmVudElkPzogc3RyaW5nfSkgPT4gdm9pZCB8IFByb21pc2U8dm9pZD59IGNhbGxiYWNrIC0gQ2FsbGJhY2sgaW52b2tlZCBmb3IgZWFjaCBldmVudCBvbiB0aGUgY2hhbm5lbC5cbiAgICogQHJldHVybnMgeygpID0+IHZvaWR9IC0gVW5zdWJzY3JpYmUgZnVuY3Rpb24uXG4gICAqL1xuICBzdWJzY3JpYmUoY2hhbm5lbCwgY2FsbGJhY2spIHtcbiAgICBpZiAoIWNoYW5uZWwpIHRocm93IG5ldyBFcnJvcihcImNoYW5uZWwgaXMgcmVxdWlyZWRcIilcbiAgICBpZiAodHlwZW9mIGNhbGxiYWNrICE9PSBcImZ1bmN0aW9uXCIpIHRocm93IG5ldyBFcnJvcihcImNhbGxiYWNrIG11c3QgYmUgYSBmdW5jdGlvblwiKVxuXG4gICAgbGV0IHNldCA9IHRoaXMuX3N1YnNjcmliZXJzLmdldChjaGFubmVsKVxuXG4gICAgaWYgKCFzZXQpIHtcbiAgICAgIHNldCA9IG5ldyBTZXQoKVxuICAgICAgdGhpcy5fc3Vic2NyaWJlcnMuc2V0KGNoYW5uZWwsIHNldClcbiAgICB9XG5cbiAgICBzZXQuYWRkKGNhbGxiYWNrKVxuXG4gICAgcmV0dXJuICgpID0+IHRoaXMudW5zdWJzY3JpYmUoY2hhbm5lbCwgY2FsbGJhY2spXG4gIH1cblxuICAvKipcbiAgICogUnVucyB1bnN1YnNjcmliZS5cbiAgICogQHBhcmFtIHtzdHJpbmd9IGNoYW5uZWwgLSBDaGFubmVsIG5hbWUuXG4gICAqIEBwYXJhbSB7KHBheWxvYWQ6ID8sIG1ldGE6IHtjaGFubmVsOiBzdHJpbmcsIGNyZWF0ZWRBdD86IHN0cmluZywgZXZlbnRJZD86IHN0cmluZ30pID0+IHZvaWQgfCBQcm9taXNlPHZvaWQ+fSBjYWxsYmFjayAtIFByZXZpb3VzbHkgcmVnaXN0ZXJlZCBjYWxsYmFjay5cbiAgICogQHJldHVybnMge3ZvaWR9XG4gICAqL1xuICB1bnN1YnNjcmliZShjaGFubmVsLCBjYWxsYmFjaykge1xuICAgIGNvbnN0IHNldCA9IHRoaXMuX3N1YnNjcmliZXJzLmdldChjaGFubmVsKVxuXG4gICAgaWYgKCFzZXQpIHJldHVyblxuXG4gICAgc2V0LmRlbGV0ZShjYWxsYmFjaylcblxuICAgIGlmIChzZXQuc2l6ZSA9PT0gMCkge1xuICAgICAgdGhpcy5fc3Vic2NyaWJlcnMuZGVsZXRlKGNoYW5uZWwpXG4gICAgfVxuICB9XG5cbiAgLyoqXG4gICAqIFJ1bnMgaGFzIHN1YnNjcmliZXJzLlxuICAgKiBAcGFyYW0ge3N0cmluZ30gY2hhbm5lbCAtIENoYW5uZWwgbmFtZS5cbiAgICogQHJldHVybnMge2Jvb2xlYW59IC0gV2hldGhlciBhbnkgc3Vic2NyaWJlcnMgZXhpc3QgZm9yIHRoZSBjaGFubmVsLlxuICAgKi9cbiAgaGFzU3Vic2NyaWJlcnMoY2hhbm5lbCkge1xuICAgIGNvbnN0IHNldCA9IHRoaXMuX3N1YnNjcmliZXJzLmdldChjaGFubmVsKVxuXG4gICAgcmV0dXJuIEJvb2xlYW4oc2V0ICYmIHNldC5zaXplID4gMClcbiAgfVxuXG4gIC8qKlxuICAgKiBEaXNwYXRjaCBhbiBldmVudCB0byBhbGwgc3Vic2NyaWJlcnMgb2YgdGhlIGNoYW5uZWwuXG4gICAqIEBwYXJhbSB7b2JqZWN0fSBhcmdzIC0gRXZlbnQgYXJncy5cbiAgICogQHBhcmFtIHtzdHJpbmd9IGFyZ3MuY2hhbm5lbCAtIENoYW5uZWwgbmFtZS5cbiAgICogQHBhcmFtIHs/fSBhcmdzLnBheWxvYWQgLSBFdmVudCBwYXlsb2FkLlxuICAgKiBAcGFyYW0ge3N0cmluZ30gW2FyZ3MuY3JlYXRlZEF0XSAtIEV2ZW50IGNyZWF0aW9uIHRpbWUuXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBbYXJncy5ldmVudElkXSAtIEV2ZW50IGlkZW50aWZpZXIuXG4gICAqIEByZXR1cm5zIHtQcm9taXNlPHZvaWQ+fSAtIFJlc29sdmVzIHdoZW4gYWxsIHN1YnNjcmliZXJzIGhhdmUgY29tcGxldGVkLlxuICAgKi9cbiAgYXN5bmMgZGlzcGF0Y2goe2NoYW5uZWwsIHBheWxvYWQsIGNyZWF0ZWRBdCwgZXZlbnRJZH0pIHtcbiAgICBjb25zdCBzZXQgPSB0aGlzLl9zdWJzY3JpYmVycy5nZXQoY2hhbm5lbClcblxuICAgIGlmICghc2V0IHx8IHNldC5zaXplID09PSAwKSByZXR1cm5cblxuICAgIC8vIFNuYXBzaG90IHRoZSBzdWJzY3JpYmVycyBzbyBjYWxsYmFja3MgdGhhdCB1bnN1YnNjcmliZSAodGhlbXNlbHZlcyBvclxuICAgIC8vIG90aGVycykgZHVyaW5nIGRpc3BhdGNoIGRvIG5vdCBza2lwIGxhdGVyIGRlbGl2ZXJpZXMgZm9yIHRoaXMgZXZlbnQuXG4gICAgY29uc3QgY2FsbGJhY2tzID0gQXJyYXkuZnJvbShzZXQpXG4gICAgY29uc3QgbWV0YSA9IHtjaGFubmVsLCBjcmVhdGVkQXQsIGV2ZW50SWR9XG4gICAgY29uc3QgdGFza3MgPSBbXVxuXG4gICAgZm9yIChjb25zdCBjYWxsYmFjayBvZiBjYWxsYmFja3MpIHtcbiAgICAgIHRyeSB7XG4gICAgICAgIGNvbnN0IHJlc3VsdCA9IGNhbGxiYWNrKHBheWxvYWQsIG1ldGEpXG5cbiAgICAgICAgaWYgKHJlc3VsdCAmJiB0eXBlb2YgKC8qKlxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICogTmFycm93cyB0aGUgcnVudGltZSB2YWx1ZSB0byB0aGUgZG9jdW1lbnRlZCB0eXBlLlxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBAdHlwZSB7UHJvbWlzZTx2b2lkPn0gKi8gKHJlc3VsdCkpLnRoZW4gPT09IFwiZnVuY3Rpb25cIikge1xuICAgICAgICAgIHRhc2tzLnB1c2goLyoqXG4gICAgICAgICAgICAgICAgICAgICAgKiBOYXJyb3dzIHRoZSBydW50aW1lIHZhbHVlIHRvIHRoZSBkb2N1bWVudGVkIHR5cGUuXG4gICAgICAgICAgICAgICAgICAgICAgIEB0eXBlIHtQcm9taXNlPHZvaWQ+fSAqLyAocmVzdWx0KSlcbiAgICAgICAgfVxuICAgICAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICAgICAgLy8gRG9uJ3QgbGV0IG9uZSBzdWJzY3JpYmVyJ3MgZmFpbHVyZSBhYm9ydCB0aGUgb3RoZXJzOyBzdXJmYWNlIHZpYSB0aGUgcmV0dXJuZWQgcHJvbWlzZXMgaW5zdGVhZC5cbiAgICAgICAgdGFza3MucHVzaChQcm9taXNlLnJlamVjdChlcnJvcikpXG4gICAgICB9XG4gICAgfVxuXG4gICAgYXdhaXQgUHJvbWlzZS5hbGwodGFza3MpXG4gIH1cbn1cbiJdfQ==