skillprint-js-sdk 1.1.0-beta.1

package/dist/index.global.js

@@ -0,0 +1,1236 @@
+"use strict";
+var SkillprintSDK = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    ApiEnvironment: () => ApiEnvironment,
+    GenericCanvasSkillprintAdapter: () => GenericCanvasSkillprintAdapter,
+    LogLevel: () => LogLevel,
+    Mood: () => Mood,
+    ParameterDefinition: () => ParameterDefinition,
+    ParameterInfo: () => ParameterInfo,
+    ParameterType: () => ParameterType,
+    ParameterUpdateResult: () => ParameterUpdateResult,
+    PhaserSkillprintAdapter: () => PhaserSkillprintAdapter,
+    PixiSkillprintAdapter: () => PixiSkillprintAdapter,
+    PollResultsResponse: () => PollResultsResponse,
+    ScreenshotUtility: () => ScreenshotUtility,
+    SkillprintAPIClient: () => SkillprintAPIClient,
+    SkillprintConfig: () => SkillprintConfig,
+    SkillprintManager: () => SkillprintManager,
+    SkillprintSessionHelper: () => SkillprintSessionHelper,
+    StartSessionRequest: () => StartSessionRequest,
+    ThreeSkillprintAdapter: () => ThreeSkillprintAdapter,
+    WebGLUrlParameterExtractor: () => WebGLUrlParameterExtractor
+  });
+
+  // src/constants.ts
+  var ApiEnvironment = /* @__PURE__ */ ((ApiEnvironment2) => {
+    ApiEnvironment2["PRODUCTION"] = "production";
+    ApiEnvironment2["STAGING"] = "staging";
+    return ApiEnvironment2;
+  })(ApiEnvironment || {});
+  var ParameterType = /* @__PURE__ */ ((ParameterType2) => {
+    ParameterType2["FLOAT"] = "Float";
+    ParameterType2["INTEGER"] = "Integer";
+    ParameterType2["BOOLEAN"] = "Boolean";
+    return ParameterType2;
+  })(ParameterType || {});
+  var Mood = /* @__PURE__ */ ((Mood2) => {
+    Mood2["RELAX"] = "relax";
+    Mood2["FOCUS"] = "focus";
+    Mood2["CREATIVITY"] = "creativity";
+    Mood2["COLLABORATE"] = "collaborate";
+    Mood2["GRIT"] = "grit";
+    Mood2["JOY"] = "joy";
+    Mood2["CURIOSITY"] = "curiosity";
+    Mood2["EMPATHY"] = "empathy";
+    Mood2["AWE"] = "awe";
+    return Mood2;
+  })(Mood || {});
+  var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+    LogLevel2["INFO"] = "info";
+    LogLevel2["WARNING"] = "warning";
+    LogLevel2["ERROR"] = "error";
+    return LogLevel2;
+  })(LogLevel || {});
+
+  // src/config.ts
+  var SkillprintConfig = class {
+    constructor(options = {}) {
+      this.gameName = options.gameName || "GAME NAME SLUG REGISTERED IN SKILLPRINT API";
+      this.targetEnvironment = options.targetEnvironment || "production" /* PRODUCTION */;
+      this.productionPartnerApiKey = options.productionPartnerApiKey || "";
+      this.productionApiBaseUrl = options.productionApiBaseUrl || "https://api.skillprint.com/v1";
+      this.stagingPartnerApiKey = options.stagingPartnerApiKey || "";
+      this.stagingApiBaseUrl = options.stagingApiBaseUrl || "https://staging-api.skillprint.com/v1";
+      this.gameParameters = options.gameParameters || [];
+      this.screenshotIntervalSeconds = options.screenshotIntervalSeconds ?? 2;
+      this.screenshotPostIntervalSeconds = options.screenshotPostIntervalSeconds ?? 5;
+      this.pollResultsIntervalSeconds = options.pollResultsIntervalSeconds ?? 5;
+      this.enableDebugLogging = options.enableDebugLogging ?? false;
+    }
+    /**
+     * Resolves the active partner API key based on current targetEnvironment.
+     */
+    get activePartnerApiKey() {
+      switch (this.targetEnvironment) {
+        case "production" /* PRODUCTION */:
+          return this.productionPartnerApiKey;
+        case "staging" /* STAGING */:
+          return this.stagingPartnerApiKey || this.productionPartnerApiKey;
+        default:
+          return this.productionPartnerApiKey;
+      }
+    }
+    /**
+     * Resolves the active API base URL based on current targetEnvironment.
+     */
+    get activeApiBaseUrl() {
+      switch (this.targetEnvironment) {
+        case "production" /* PRODUCTION */:
+          return this.productionApiBaseUrl;
+        case "staging" /* STAGING */:
+          return this.stagingApiBaseUrl;
+        default:
+          return this.productionApiBaseUrl;
+      }
+    }
+  };
+
+  // src/parameter-definition.ts
+  var ParameterDefinition = class {
+    constructor(options = {}) {
+      this.updateAction = null;
+      this.parameterName = options.parameterName || "";
+      this.description = options.description || "";
+      this.howSDKChangesIt = options.howSDKChangesIt || "";
+      this.type = options.type || "Float" /* FLOAT */;
+      this.minValue = options.minValue ?? 0;
+      this.maxValue = options.maxValue ?? 100;
+      this.defaultValue = options.defaultValue ?? "";
+      this.updateAction = null;
+    }
+    /**
+     * Checks if a converted value is valid for this parameter type and range.
+     * @param value The value to validate
+     */
+    isValid(value) {
+      switch (this.type) {
+        case "Float" /* FLOAT */:
+          return typeof value === "number" && !isNaN(value) && value >= this.minValue && value <= this.maxValue;
+        case "Integer" /* INTEGER */:
+          return typeof value === "number" && Number.isInteger(value) && value >= this.minValue && value <= this.maxValue;
+        case "Boolean" /* BOOLEAN */:
+          return typeof value === "boolean";
+        default:
+          return false;
+      }
+    }
+    /**
+     * Converts a raw API value into the defined type for this parameter.
+     * @param rawValue Raw incoming value from API
+     */
+    convertValue(rawValue) {
+      if (rawValue === null || rawValue === void 0) {
+        return null;
+      }
+      try {
+        switch (this.type) {
+          case "Float" /* FLOAT */: {
+            const parsedFloat = parseFloat(String(rawValue));
+            return isNaN(parsedFloat) ? null : parsedFloat;
+          }
+          case "Integer" /* INTEGER */: {
+            const parsedInt = parseInt(String(rawValue), 10);
+            return isNaN(parsedInt) ? null : parsedInt;
+          }
+          case "Boolean" /* BOOLEAN */: {
+            if (typeof rawValue === "boolean") return rawValue;
+            if (typeof rawValue === "string") {
+              const lower = rawValue.trim().toLowerCase();
+              if (lower === "true" || lower === "1") return true;
+              if (lower === "false" || lower === "0") return false;
+            }
+            return Boolean(rawValue);
+          }
+          default:
+            return String(rawValue);
+        }
+      } catch (error) {
+        console.error(`Error converting value for parameter ${this.parameterName}:`, error);
+        return null;
+      }
+    }
+  };
+
+  // src/api-models.ts
+  var StartSessionRequest = class {
+    constructor(sessionId, game, targetMood) {
+      this.sessionId = sessionId;
+      this.game = game;
+      this.targetMood = targetMood;
+    }
+  };
+  var ParameterInfo = class {
+    constructor(name, type, description, minValue = null, maxValue = null) {
+      this.name = name;
+      this.type = type;
+      this.description = description;
+      this.minValue = minValue;
+      this.maxValue = maxValue;
+    }
+  };
+  var ParameterUpdateResult = class {
+    constructor(data = {}) {
+      this.parameterName = data.parameterName || "";
+      this.newValue = data.newValue;
+      this._rawJson = JSON.stringify(data);
+      Object.keys(data).forEach((key) => {
+        if (!(key in this)) {
+          this[key] = data[key];
+        }
+      });
+    }
+    /**
+     * Extracts parsed new value from response payload.
+     */
+    getParsedValue() {
+      if (this.newValue !== null && this.newValue !== void 0 && this.newValue !== "") {
+        return this.newValue;
+      }
+      if (this.parameterName && this[this.parameterName] !== void 0) {
+        return this[this.parameterName];
+      }
+      return null;
+    }
+    /**
+     * Converts value to target primitive type.
+     * @param targetType Target primitive type string ('number', 'integer', 'boolean', 'string')
+     */
+    convertToType(targetType) {
+      const value = this.getParsedValue();
+      if (value === null || value === void 0) {
+        return null;
+      }
+      try {
+        switch (targetType.toLowerCase()) {
+          case "number":
+          case "float": {
+            const val = Number(value);
+            return isNaN(val) ? null : val;
+          }
+          case "integer": {
+            const val = parseInt(String(value), 10);
+            return isNaN(val) ? null : val;
+          }
+          case "boolean": {
+            if (typeof value === "boolean") return value;
+            if (typeof value === "string") {
+              const lower = value.trim().toLowerCase();
+              if (lower === "true" || lower === "1") return true;
+              if (lower === "false" || lower === "0") return false;
+            }
+            return Boolean(value);
+          }
+          case "string":
+            return String(value);
+          default:
+            return value;
+        }
+      } catch (error) {
+        console.error(`Failed to convert value '${String(value)}' to type ${targetType}:`, error);
+        return null;
+      }
+    }
+    /**
+     * Converts value based on parameter definition type and applies range clamping if necessary.
+     * @param paramDef Parameter definition object
+     */
+    convertToParameterType(paramDef) {
+      const rawValue = this.getParsedValue();
+      if (rawValue === null || rawValue === void 0) {
+        return null;
+      }
+      try {
+        let convertedValue;
+        switch (paramDef.type) {
+          case "Float" /* FLOAT */:
+            convertedValue = parseFloat(String(rawValue));
+            if (isNaN(convertedValue)) return null;
+            break;
+          case "Integer" /* INTEGER */:
+            convertedValue = parseInt(String(rawValue), 10);
+            if (isNaN(convertedValue)) return null;
+            break;
+          case "Boolean" /* BOOLEAN */:
+            if (typeof rawValue === "boolean") {
+              convertedValue = rawValue;
+            } else if (typeof rawValue === "string") {
+              const lower = rawValue.trim().toLowerCase();
+              convertedValue = lower === "true" || lower === "1";
+            } else {
+              convertedValue = Boolean(rawValue);
+            }
+            break;
+          default:
+            convertedValue = String(rawValue);
+            break;
+        }
+        if (paramDef.isValid(convertedValue)) {
+          return convertedValue;
+        } else {
+          console.warn(
+            `Converted value ${String(convertedValue)} for parameter ${this.parameterName} is outside valid range [${paramDef.minValue}, ${paramDef.maxValue}]`
+          );
+          if (paramDef.type === "Float" /* FLOAT */ && typeof convertedValue === "number") {
+            return Math.max(paramDef.minValue, Math.min(paramDef.maxValue, convertedValue));
+          } else if (paramDef.type === "Integer" /* INTEGER */ && typeof convertedValue === "number") {
+            return Math.max(Math.floor(paramDef.minValue), Math.min(Math.floor(paramDef.maxValue), convertedValue));
+          }
+          return convertedValue;
+        }
+      } catch (error) {
+        console.error(`Error converting parameter ${this.parameterName}:`, error);
+        return null;
+      }
+    }
+  };
+  var PollResultsResponse = class {
+    constructor(data = {}) {
+      this.gameplayTips = data.gameplayTips || "";
+      this.state = data.state || "";
+      this.parameterUpdates = (data.parameterUpdates || []).map((update) => new ParameterUpdateResult(update));
+    }
+  };
+
+  // src/api-client.ts
+  var SkillprintAPIClient = class {
+    constructor(baseUrl, partnerApiKey, logger) {
+      // API Endpoints
+      this.START_SESSION_ENDPOINT = "/games/api/sessions/";
+      this.UPLOAD_SCREENSHOTS_ENDPOINT = "/games/api/record-session/{sessionId}/";
+      this.POLL_RESULTS_ENDPOINT = "/games/api/sessions/{sessionId}/";
+      this.CREATE_USER_ENDPOINT = "/partners/api/users/add/";
+      this.GET_USER_TOKEN_ENDPOINT = "/partners/api/users/auth/token/";
+      this.baseUrl = baseUrl.replace(/\/$/, "");
+      this.partnerApiKey = partnerApiKey;
+      this.logger = logger;
+    }
+    /**
+     * Starts a new Skillprint session.
+     */
+    async startSession(sessionId, targetMood, customPlayerId = null, gameName = "", _gameParameters = []) {
+      const url = `${this.baseUrl}${this.START_SESSION_ENDPOINT}`;
+      this.logger?.(`Starting session: POST ${url}`, "info" /* INFO */);
+      this.logger?.(`Starting session: MOOD ${targetMood}`, "warning" /* WARNING */);
+      const validMoods = Object.values(Mood);
+      if (!validMoods.includes(targetMood)) {
+        const errorMessage = `Invalid targetMood: '${targetMood}'. Valid moods are: ${validMoods.join(", ")}.`;
+        this.logger?.(errorMessage, "error" /* ERROR */);
+        throw new Error(errorMessage);
+      }
+      let userToken = null;
+      if (customPlayerId) {
+        try {
+          userToken = await this.createOrGetUserToken(customPlayerId);
+          this.logger?.(`User token obtained successfully for player: ${customPlayerId}`, "info" /* INFO */);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          this.logger?.(`Failed to obtain user token: ${message}`, "error" /* ERROR */);
+          this.logger?.("Proceeding with session creation without user token", "warning" /* WARNING */);
+        }
+      }
+      const requestData = new StartSessionRequest(sessionId, gameName, targetMood);
+      const headers = {
+        "Content-Type": "application/json",
+        "Authorization": `Api-Key ${this.partnerApiKey}`
+      };
+      if (userToken) {
+        headers["X-Auth-Token"] = `Token ${userToken}`;
+      }
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(requestData)
+        });
+        const responseText = await response.text();
+        if (response.ok) {
+          this.logger?.(`StartSession successful. Response: ${responseText}`, "info" /* INFO */);
+          return { success: true, data: responseText };
+        } else {
+          this.logger?.(`StartSession Error: ${response.status}. Response: ${responseText}`, "error" /* ERROR */);
+          throw new Error(`${response.status} | ${responseText}`);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger?.(`StartSession Error: ${message}`, "error" /* ERROR */);
+        throw error;
+      }
+    }
+    /**
+     * Uploads a batch of captured screenshots for an active session.
+     */
+    async postScreenshots(sessionId, screenshots, isLastChunk = false) {
+      const endpoint = this.UPLOAD_SCREENSHOTS_ENDPOINT.replace("{sessionId}", sessionId);
+      const url = `${this.baseUrl}${endpoint}`;
+      this.logger?.(`Posting ${screenshots.length} screenshots (isLastChunk: ${isLastChunk}): POST ${url}`, "info" /* INFO */);
+      if (screenshots.length === 0 && !isLastChunk) {
+        const errorMsg = "No screenshots provided, and 'is_last_chunk' is false. API likely requires files in this case.";
+        this.logger?.(errorMsg, "warning" /* WARNING */);
+        throw new Error(errorMsg);
+      }
+      const formData = new FormData();
+      formData.append("is_last_chunk", isLastChunk.toString().toLowerCase());
+      for (let i = 0; i < screenshots.length; i++) {
+        const screenshot = screenshots[i];
+        if (screenshot) {
+          const fieldName = `screenshot${i}`;
+          const filename = `screenshot_${i}.jpg`;
+          formData.append(fieldName, screenshot, filename);
+        } else {
+          this.logger?.(`Screenshot at index ${i} is null, skipping.`, "warning" /* WARNING */);
+        }
+      }
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Authorization": `Api-Key ${this.partnerApiKey}`
+          },
+          body: formData
+        });
+        const responseText = await response.text();
+        if (response.ok) {
+          this.logger?.(`PostScreenshots successful. Response: ${responseText}`, "info" /* INFO */);
+          return { success: true, data: responseText };
+        } else {
+          this.logger?.(`PostScreenshots Error: ${response.status}. Response: ${responseText}`, "error" /* ERROR */);
+          throw new Error(`${response.status} | ${responseText}`);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger?.(`PostScreenshots Error: ${message}`, "error" /* ERROR */);
+        throw error;
+      }
+    }
+    /**
+     * Polls API for updated parameter values for the active session.
+     */
+    async pollParameterResults(sessionId) {
+      const endpoint = this.POLL_RESULTS_ENDPOINT.replace("{sessionId}", sessionId);
+      const url = `${this.baseUrl}${endpoint}`;
+      this.logger?.(`Polling results: GET ${url}`, "info" /* INFO */);
+      try {
+        const response = await fetch(url, {
+          method: "GET",
+          headers: {
+            "Authorization": `Api-Key ${this.partnerApiKey}`,
+            "Accept": "application/json"
+          }
+        });
+        const responseText = await response.text();
+        if (response.ok) {
+          this.logger?.(`PollResults successful. Response: ${responseText}`, "info" /* INFO */);
+          try {
+            const parsedResponse = JSON.parse(responseText);
+            const pollResults = new PollResultsResponse(parsedResponse);
+            if (pollResults.parameterUpdates && pollResults.parameterUpdates.length > 0) {
+              this.logger?.(`Successfully parsed ${pollResults.parameterUpdates.length} parameter updates`, "info" /* INFO */);
+              pollResults.parameterUpdates.forEach((update) => {
+                const parsedValue = update.getParsedValue();
+                this.logger?.(
+                  `Parameter Update: ${update.parameterName} = ${String(parsedValue)} (Type: ${typeof parsedValue})`,
+                  "info" /* INFO */
+                );
+              });
+            } else {
+              this.logger?.("No parameter updates found in response", "warning" /* WARNING */);
+            }
+            return { success: true, data: pollResults.parameterUpdates || [] };
+          } catch (parseError) {
+            const message = parseError instanceof Error ? parseError.message : String(parseError);
+            this.logger?.(`PollResults JSON parsing error: ${message}. Response: ${responseText}`, "error" /* ERROR */);
+            throw parseError;
+          }
+        } else {
+          this.logger?.(`PollResults Error: ${response.status}. Response: ${responseText}`, "error" /* ERROR */);
+          throw new Error(`${response.status} | ${responseText}`);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger?.(`PollResults Error: ${message}`, "error" /* ERROR */);
+        throw error;
+      }
+    }
+    /**
+     * Creates or fetches user auth token for custom player ID.
+     */
+    async createOrGetUserToken(customPlayerId) {
+      if (!customPlayerId) {
+        throw new Error("Custom player ID cannot be null or empty");
+      }
+      try {
+        return await this.getUserToken(customPlayerId);
+      } catch {
+        try {
+          await this.createUser(customPlayerId);
+          return await this.getUserToken(customPlayerId);
+        } catch (createError) {
+          const message = createError instanceof Error ? createError.message : String(createError);
+          throw new Error(`Failed to create user: ${message}`);
+        }
+      }
+    }
+    /**
+     * Registers a new user with Skillprint API.
+     */
+    async createUser(internalId) {
+      const url = `${this.baseUrl}${this.CREATE_USER_ENDPOINT}`;
+      this.logger?.(`Creating user: POST ${url} with internalId: ${internalId}`, "info" /* INFO */);
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Api-Key ${this.partnerApiKey}`
+        },
+        body: JSON.stringify({ internalId })
+      });
+      const responseText = await response.text();
+      if (response.ok) {
+        this.logger?.(`CreateUser successful. Response: ${responseText}`, "info" /* INFO */);
+        return responseText;
+      } else {
+        this.logger?.(`CreateUser Error: ${response.status}. Response: ${responseText}`, "error" /* ERROR */);
+        throw new Error(`${response.status} | ${responseText}`);
+      }
+    }
+    /**
+     * Obtains auth token for existing user internalId.
+     */
+    async getUserToken(internalId) {
+      const url = `${this.baseUrl}${this.GET_USER_TOKEN_ENDPOINT}`;
+      this.logger?.(`Getting user token: POST ${url} with internalId: ${internalId}`, "info" /* INFO */);
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Api-Key ${this.partnerApiKey}`
+        },
+        body: JSON.stringify({ internalId })
+      });
+      const responseText = await response.text();
+      if (response.ok) {
+        this.logger?.(`GetUserToken successful. Response: ${responseText}`, "info" /* INFO */);
+        try {
+          const tokenResponse = JSON.parse(responseText);
+          if (tokenResponse.token) {
+            return tokenResponse.token;
+          } else {
+            throw new Error("Token not found in response");
+          }
+        } catch (parseError) {
+          const message = parseError instanceof Error ? parseError.message : String(parseError);
+          this.logger?.(`Failed to parse token response: ${message}`, "error" /* ERROR */);
+          throw new Error("Failed to parse token response");
+        }
+      } else {
+        this.logger?.(`GetUserToken Error: ${response.status}. Response: ${responseText}`, "error" /* ERROR */);
+        throw new Error(`${response.status} | ${responseText}`);
+      }
+    }
+  };
+
+  // src/screenshot-utility.ts
+  var ScreenshotUtility = class {
+    constructor(logger) {
+      this.logger = logger;
+    }
+    /**
+     * Captures a screenshot from a standard HTML canvas element as a Blob.
+     * @param canvas Target HTML Canvas element
+     * @param options Screenshot options (format, quality, max dimensions)
+     */
+    async captureScreenshot(canvas, options = {}) {
+      try {
+        const {
+          format = "image/jpeg",
+          quality = 0.8,
+          maxWidth = null,
+          maxHeight = null
+        } = options;
+        if (!canvas) {
+          throw new Error("No canvas provided for screenshot");
+        }
+        const screenshotCanvas = document.createElement("canvas");
+        const ctx = screenshotCanvas.getContext("2d");
+        if (!ctx) {
+          throw new Error("Failed to obtain 2D rendering context for screenshot canvas");
+        }
+        let targetWidth = canvas.width;
+        let targetHeight = canvas.height;
+        if (targetWidth === 0 || targetHeight === 0) {
+          throw new Error("Canvas has 0 width or height");
+        }
+        if (maxWidth && targetWidth > maxWidth) {
+          const scale = maxWidth / targetWidth;
+          targetWidth = maxWidth;
+          targetHeight = Math.floor(targetHeight * scale);
+        }
+        if (maxHeight && targetHeight > maxHeight) {
+          const scale = maxHeight / targetHeight;
+          targetHeight = maxHeight;
+          targetWidth = Math.floor(targetWidth * scale);
+        }
+        screenshotCanvas.width = targetWidth;
+        screenshotCanvas.height = targetHeight;
+        ctx.drawImage(canvas, 0, 0, targetWidth, targetHeight);
+        return new Promise((resolve) => {
+          screenshotCanvas.toBlob(
+            (blob) => {
+              if (blob) {
+                this.logger?.("Screenshot captured successfully", "info" /* INFO */);
+                resolve(blob);
+              } else {
+                this.logger?.("Failed to create screenshot blob", "error" /* ERROR */);
+                resolve(null);
+              }
+            },
+            format,
+            quality
+          );
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger?.(`Error capturing screenshot: ${message}`, "error" /* ERROR */);
+        return null;
+      }
+    }
+    /**
+     * Alternative method for WebGL contexts that don't preserve drawing buffer.
+     * Reads pixel data directly from WebGL rendering context and flips vertically.
+     * @param gl WebGL rendering context (WebGLRenderingContext | WebGL2RenderingContext)
+     * @param canvas Target HTML Canvas element
+     * @param options Screenshot options
+     */
+    async captureScreenshotWebGL(gl, canvas, options = {}) {
+      try {
+        const { format = "image/jpeg", quality = 0.8 } = options;
+        if (!gl || !canvas) {
+          throw new Error("Invalid WebGL context or canvas provided");
+        }
+        const pixels = new Uint8Array(canvas.width * canvas.height * 4);
+        gl.readPixels(0, 0, canvas.width, canvas.height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+        const tempCanvas = document.createElement("canvas");
+        tempCanvas.width = canvas.width;
+        tempCanvas.height = canvas.height;
+        const ctx = tempCanvas.getContext("2d");
+        if (!ctx) {
+          throw new Error("Failed to get 2d context for WebGL screenshot processing");
+        }
+        const imageData = ctx.createImageData(canvas.width, canvas.height);
+        for (let y = 0; y < canvas.height; y++) {
+          for (let x = 0; x < canvas.width; x++) {
+            const srcIndex = (y * canvas.width + x) * 4;
+            const dstIndex = ((canvas.height - 1 - y) * canvas.width + x) * 4;
+            imageData.data[dstIndex] = pixels[srcIndex];
+            imageData.data[dstIndex + 1] = pixels[srcIndex + 1];
+            imageData.data[dstIndex + 2] = pixels[srcIndex + 2];
+            imageData.data[dstIndex + 3] = pixels[srcIndex + 3];
+          }
+        }
+        ctx.putImageData(imageData, 0, 0);
+        return new Promise((resolve) => {
+          tempCanvas.toBlob(
+            (blob) => {
+              if (blob) {
+                this.logger?.("WebGL screenshot captured successfully", "info" /* INFO */);
+                resolve(blob);
+              } else {
+                this.logger?.("Failed to create WebGL screenshot blob", "error" /* ERROR */);
+                resolve(null);
+              }
+            },
+            format,
+            quality
+          );
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger?.(`Error capturing WebGL screenshot: ${message}`, "error" /* ERROR */);
+        return null;
+      }
+    }
+  };
+
+  // src/url-parameter-extractor.ts
+  var WebGLUrlParameterExtractor = class {
+    /**
+     * Retrieves a URL query parameter by key.
+     * @param parameterName Name of the URL query parameter
+     */
+    static getUrlParameter(parameterName) {
+      try {
+        if (!this.isUrlParameterSupported()) return null;
+        const url = new URL(window.location.href);
+        return url.searchParams.get(parameterName);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`Failed to get URL parameter '${parameterName}': ${message}`);
+        return null;
+      }
+    }
+    /**
+     * Gets current window URL string.
+     */
+    static getCurrentUrl() {
+      try {
+        if (!this.isUrlParameterSupported()) return null;
+        return window.location.href;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`Failed to get current URL: ${message}`);
+        return null;
+      }
+    }
+    /**
+     * Extracts targetMood and playerId from URL query parameters.
+     */
+    static getSkillprintUrlParameters() {
+      const targetMood = this.getUrlParameter("mood") || this.getUrlParameter("targetMood");
+      const playerId = this.getUrlParameter("playerId") || this.getUrlParameter("player_id") || this.getUrlParameter("userId");
+      if (typeof window !== "undefined" && window.localStorage) {
+        if (targetMood) {
+          try {
+            localStorage.setItem("SkillprintMood", targetMood);
+          } catch {
+          }
+        }
+        if (playerId) {
+          try {
+            localStorage.setItem("SkillprintPlayerId", playerId);
+          } catch {
+          }
+        }
+      }
+      return { targetMood, playerId };
+    }
+    /**
+     * Returns true if running in browser context with URL access.
+     */
+    static isUrlParameterSupported() {
+      return typeof window !== "undefined" && typeof window.location !== "undefined";
+    }
+  };
+  var SkillprintSessionHelper = class {
+    /**
+     * Starts a Skillprint session, attempting to auto-extract parameters from URL.
+     * @param manager SkillprintManager instance
+     * @param fallbackMood Mood to use if not found in URL
+     * @param fallbackPlayerId Player ID to use if not found in URL
+     * @param overrideMood Forced mood override
+     * @param overridePlayerId Forced player ID override
+     */
+    static startSessionWithUrlParams(manager, fallbackMood = "focus" /* FOCUS */, fallbackPlayerId = null, overrideMood = null, overridePlayerId = null) {
+      if (!manager) {
+        console.error("SkillprintManager is null. Cannot start session.");
+        return;
+      }
+      let targetMood = overrideMood;
+      let playerId = overridePlayerId;
+      if (!targetMood || !playerId) {
+        if (WebGLUrlParameterExtractor.isUrlParameterSupported()) {
+          const urlParams = WebGLUrlParameterExtractor.getSkillprintUrlParameters();
+          if (!targetMood) {
+            targetMood = urlParams.targetMood || fallbackMood;
+          }
+          if (!playerId) {
+            playerId = urlParams.playerId || fallbackPlayerId;
+          }
+          manager.log(`URL Parameters - Mood: '${targetMood}', Player ID: '${playerId}'`, "info" /* INFO */);
+        } else {
+          if (!targetMood) targetMood = fallbackMood;
+          if (!playerId) playerId = fallbackPlayerId;
+          manager.log(
+            `Non-browser Platform - Using fallback values. Mood: '${targetMood}', Player ID: '${playerId}'`,
+            "info" /* INFO */
+          );
+        }
+      }
+      if (!targetMood) {
+        manager.log("No target mood specified and no fallback provided. Using 'focus' as default.", "warning" /* WARNING */);
+        targetMood = "focus" /* FOCUS */;
+      }
+      const validMoods = Object.values(Mood);
+      if (!validMoods.includes(targetMood)) {
+        manager.log(
+          `Invalid mood '${targetMood}'. Valid moods: ${validMoods.join(", ")}. Using 'focus' as fallback.`,
+          "warning" /* WARNING */
+        );
+        targetMood = "focus" /* FOCUS */;
+      }
+      manager.log(
+        `Starting Skillprint session with Mood: '${targetMood}', Player ID: '${playerId || "none"}'`,
+        "info" /* INFO */
+      );
+      manager.startGameSession(targetMood, playerId);
+    }
+  };
+
+  // src/manager.ts
+  var _SkillprintManager = class _SkillprintManager {
+    constructor(config, canvasProvider) {
+      this.currentSessionId = null;
+      this.isSessionActive = false;
+      this.apiClient = null;
+      this.screenshotUtility = null;
+      this.screenshotQueue = [];
+      this.registeredParameters = /* @__PURE__ */ new Map();
+      // Timers
+      this.screenshotCaptureTimer = null;
+      this.screenshotPostTimer = null;
+      this.pollResultsTimer = null;
+      if (_SkillprintManager.instance) {
+        console.warn("Another instance of SkillprintManager already exists. Using existing instance.");
+        return _SkillprintManager.instance;
+      }
+      this.config = config;
+      this.canvasProvider = canvasProvider;
+      this.currentSessionId = null;
+      this.isSessionActive = false;
+      this.apiClient = null;
+      this.screenshotUtility = null;
+      this.screenshotQueue = [];
+      this.registeredParameters = /* @__PURE__ */ new Map();
+      this.initializeSDK();
+      _SkillprintManager.instance = this;
+    }
+    static getInstance() {
+      return _SkillprintManager.instance;
+    }
+    initializeSDK() {
+      if (!this.config) {
+        console.error("SkillprintConfig not provided to SkillprintManager. SDK will not function.");
+        return;
+      }
+      if (!this.config.activePartnerApiKey) {
+        this.log(
+          `Partner API Key for ${this.config.targetEnvironment} environment is not set. SDK will not function.`,
+          "error" /* ERROR */
+        );
+        return;
+      }
+      if (!this.config.activeApiBaseUrl) {
+        this.log(
+          `API Base URL for ${this.config.targetEnvironment} environment is not set. SDK will not function.`,
+          "error" /* ERROR */
+        );
+        return;
+      }
+      this.apiClient = new SkillprintAPIClient(
+        this.config.activeApiBaseUrl,
+        this.config.activePartnerApiKey,
+        this.log.bind(this)
+      );
+      this.screenshotUtility = new ScreenshotUtility(this.log.bind(this));
+      this.config.gameParameters.forEach((paramDefOptions) => {
+        const paramDef = new ParameterDefinition(paramDefOptions);
+        if (!this.registeredParameters.has(paramDef.parameterName)) {
+          this.registeredParameters.set(paramDef.parameterName, paramDef);
+        } else {
+          this.log(
+            `Duplicate parameter name found in config: ${paramDef.parameterName}. Using first occurrence.`,
+            "warning" /* WARNING */
+          );
+        }
+      });
+      this.log(
+        `Skillprint SDK Initialized for ${this.config.targetEnvironment} environment (URL: ${this.config.activeApiBaseUrl}).`
+      );
+    }
+    /**
+     * Registers a modifier callback action for a named parameter.
+     * @param parameterName Unique parameter identifier
+     * @param updateAction Callback invoked when Skillprint modifies this parameter
+     * @param expectedType Optional type check string ('number', 'integer', 'boolean')
+     */
+    registerParameterModifier(parameterName, updateAction, expectedType = null) {
+      const paramDef = this.registeredParameters.get(parameterName);
+      if (paramDef) {
+        if (expectedType) {
+          let typeMatch = false;
+          if (expectedType === "number" && paramDef.type === "Float" /* FLOAT */) typeMatch = true;
+          else if (expectedType === "integer" && paramDef.type === "Integer" /* INTEGER */) typeMatch = true;
+          else if (expectedType === "boolean" && paramDef.type === "Boolean" /* BOOLEAN */) typeMatch = true;
+          if (!typeMatch) {
+            this.log(
+              `Type mismatch for parameter '${parameterName}'. Expected ${paramDef.type}, but got ${expectedType}. Modifier not registered.`,
+              "error" /* ERROR */
+            );
+            return;
+          }
+        }
+        paramDef.updateAction = (value) => {
+          try {
+            updateAction(value);
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.log(`Error in update action for parameter '${parameterName}': ${message}`, "error" /* ERROR */);
+          }
+        };
+        this.log(`Parameter '${parameterName}' modifier registered successfully.`);
+      } else {
+        this.log(
+          `Attempted to register modifier for undefined parameter: '${parameterName}'. Ensure it's in SkillprintConfig.`,
+          "warning" /* WARNING */
+        );
+      }
+    }
+    /**
+     * Starts a new Skillprint AI gameplay session.
+     * @param targetMood Target optimization mood category
+     * @param customPlayerId Optional external player identifier
+     */
+    async startGameSession(targetMood, customPlayerId = null) {
+      if (this.isSessionActive) {
+        this.log("Session already active. Call stopGameSession first.", "warning" /* WARNING */);
+        return;
+      }
+      if (!this.config || !this.config.activePartnerApiKey || !this.config.activeApiBaseUrl || !this.apiClient) {
+        this.log("SDK not configured properly (check environment settings). Cannot start session.", "error" /* ERROR */);
+        return;
+      }
+      this.currentSessionId = this.generateSessionId();
+      this.isSessionActive = true;
+      this.log(`Starting game session for ${this.config.targetEnvironment} environment.`, "info" /* INFO */);
+      const parameterInfos = Array.from(this.registeredParameters.values()).map(
+        (p) => new ParameterInfo(
+          p.parameterName,
+          String(p.type),
+          p.description,
+          p.type === "Float" /* FLOAT */ || p.type === "Integer" /* INTEGER */ ? p.minValue.toString() : null,
+          p.type === "Float" /* FLOAT */ || p.type === "Integer" /* INTEGER */ ? p.maxValue.toString() : null
+        )
+      );
+      try {
+        const result = await this.apiClient.startSession(
+          this.currentSessionId,
+          targetMood,
+          customPlayerId,
+          this.config.gameName,
+          parameterInfos
+        );
+        this.log(`Skillprint session started: ${this.currentSessionId}. Response: ${result.data}`);
+        this.startScreenshotCaptureLoop();
+        this.startScreenshotPostLoop();
+        this.startPollResultsLoop();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.log(`Failed to start Skillprint session: ${message}`, "error" /* ERROR */);
+        this.isSessionActive = false;
+        this.currentSessionId = null;
+      }
+    }
+    /**
+     * Stops the active Skillprint session and clears all loop timers.
+     */
+    stopGameSession() {
+      if (!this.isSessionActive) {
+        this.log("No active session to stop.", "warning" /* WARNING */);
+        return;
+      }
+      this.log(`Stopping Skillprint session: ${this.currentSessionId}`);
+      this.isSessionActive = false;
+      if (this.screenshotCaptureTimer) clearInterval(this.screenshotCaptureTimer);
+      if (this.screenshotPostTimer) clearInterval(this.screenshotPostTimer);
+      if (this.pollResultsTimer) clearInterval(this.pollResultsTimer);
+      this.screenshotCaptureTimer = null;
+      this.screenshotPostTimer = null;
+      this.pollResultsTimer = null;
+      this.screenshotQueue = [];
+      this.currentSessionId = null;
+      this.log("Skillprint session stopped.");
+    }
+    startScreenshotCaptureLoop() {
+      this.screenshotCaptureTimer = setInterval(async () => {
+        if (!this.isSessionActive || !this.screenshotUtility) return;
+        const canvas = this.canvasProvider?.();
+        if (!canvas) {
+          this.log("No canvas available for screenshot capture", "warning" /* WARNING */);
+          return;
+        }
+        const screenshot = await this.screenshotUtility.captureScreenshot(canvas);
+        if (screenshot) {
+          if (this.screenshotQueue.length < 50) {
+            this.screenshotQueue.push(screenshot);
+            this.log(`Screenshot captured. Queue size: ${this.screenshotQueue.length}`);
+          } else {
+            this.log("Screenshot queue full. Discarding new screenshot.", "warning" /* WARNING */);
+          }
+        }
+      }, this.config.screenshotIntervalSeconds * 1e3);
+    }
+    startScreenshotPostLoop() {
+      this.screenshotPostTimer = setInterval(async () => {
+        if (!this.isSessionActive || this.screenshotQueue.length === 0 || !this.apiClient || !this.currentSessionId) return;
+        const batchSize = Math.max(
+          1,
+          Math.ceil(this.config.screenshotPostIntervalSeconds / this.config.screenshotIntervalSeconds) * 2
+        );
+        const batchToPost = this.screenshotQueue.splice(0, Math.min(this.screenshotQueue.length, batchSize));
+        if (batchToPost.length > 0) {
+          this.log(`Posting ${batchToPost.length} screenshots...`);
+          try {
+            const result = await this.apiClient.postScreenshots(this.currentSessionId, batchToPost, false);
+            this.log(`Successfully posted ${batchToPost.length} screenshots. Response: ${result.data}`);
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.log(`Failed to post screenshots: ${message}`, "error" /* ERROR */);
+          }
+        }
+      }, this.config.screenshotPostIntervalSeconds * 1e3);
+    }
+    startPollResultsLoop() {
+      this.pollResultsTimer = setInterval(async () => {
+        if (!this.isSessionActive || !this.apiClient || !this.currentSessionId) return;
+        try {
+          const result = await this.apiClient.pollParameterResults(this.currentSessionId);
+          if (result.success && result.data && result.data.length > 0) {
+            this.log(`Received ${result.data.length} parameter updates from API.`);
+            this.applyParameterUpdates(result.data);
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          this.log(`Failed to poll results: ${message}`, "warning" /* WARNING */);
+        }
+      }, this.config.pollResultsIntervalSeconds * 1e3);
+    }
+    applyParameterUpdates(updates) {
+      updates.forEach((update) => {
+        const parsed = update.getParsedValue();
+        this.log(
+          `[DEBUG] Received update - Name: ${update.parameterName}, Value: '${String(parsed)}', Type: ${typeof parsed}`,
+          "info" /* INFO */
+        );
+        const paramDef = this.registeredParameters.get(update.parameterName);
+        if (paramDef) {
+          if (!paramDef.updateAction) {
+            this.log(
+              `Parameter '${update.parameterName}' received from API but has no registered modifier. Skipping.`,
+              "warning" /* WARNING */
+            );
+            return;
+          }
+          const convertedValue = update.convertToParameterType(paramDef);
+          if (convertedValue !== null && paramDef.isValid(convertedValue)) {
+            try {
+              this.log(`Applying update: ${paramDef.parameterName} = ${String(convertedValue)} (Type: ${String(paramDef.type)})`);
+              paramDef.updateAction(convertedValue);
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              this.log(`Error applying update for ${paramDef.parameterName}: ${message}`, "error" /* ERROR */);
+            }
+          } else {
+            this.log(
+              `Invalid value or type for parameter ${paramDef.parameterName}: '${String(update.newValue)}'. Expected type: ${String(paramDef.type)}, Range: ${paramDef.minValue}-${paramDef.maxValue}. Skipping.`,
+              "warning" /* WARNING */
+            );
+          }
+        } else {
+          this.log(`Received update for unknown parameter: ${update.parameterName}. Skipping.`, "warning" /* WARNING */);
+        }
+      });
+    }
+    generateSessionId() {
+      return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 | 0;
+        const v = c === "x" ? r : r & 3 | 8;
+        return v.toString(16);
+      });
+    }
+    log(message, level = "info" /* INFO */) {
+      if (!this.config.enableDebugLogging && level === "info" /* INFO */) return;
+      const prefix = "[SkillprintSDK]";
+      switch (level) {
+        case "info" /* INFO */:
+          console.log(`${prefix} ${message}`);
+          break;
+        case "warning" /* WARNING */:
+          console.warn(`${prefix} ${message}`);
+          break;
+        case "error" /* ERROR */:
+          console.error(`${prefix} ${message}`);
+          break;
+      }
+    }
+    getCurrentSessionId() {
+      return this.currentSessionId;
+    }
+    getConfig() {
+      return this.config;
+    }
+    // WebGL convenience methods
+    startGameSessionFromUrl(fallbackMood = "relax" /* RELAX */, fallbackPlayerId = null) {
+      SkillprintSessionHelper.startSessionWithUrlParams(this, fallbackMood, fallbackPlayerId);
+    }
+    startGameSessionWithOverrides(fallbackMood = "relax" /* RELAX */, fallbackPlayerId = null, overrideMood = null, overridePlayerId = null) {
+      SkillprintSessionHelper.startSessionWithUrlParams(
+        this,
+        fallbackMood,
+        fallbackPlayerId,
+        overrideMood,
+        overridePlayerId
+      );
+    }
+    getUrlParametersInfo() {
+      if (!WebGLUrlParameterExtractor.isUrlParameterSupported()) {
+        return "URL parameters not supported on this platform (not in browser)";
+      }
+      const currentUrl = WebGLUrlParameterExtractor.getCurrentUrl();
+      const urlParams = WebGLUrlParameterExtractor.getSkillprintUrlParameters();
+      return `Current URL: ${currentUrl}
+Mood Parameter: '${urlParams.targetMood || "not found"}'
+Player ID Parameter: '${urlParams.playerId || "not found"}'`;
+    }
+  };
+  _SkillprintManager.instance = null;
+  var SkillprintManager = _SkillprintManager;
+
+  // src/adapters/phaser.ts
+  var PhaserSkillprintAdapter = class _PhaserSkillprintAdapter {
+    constructor(scene, config) {
+      this.scene = scene;
+      this.config = config;
+      this.manager = new SkillprintManager(config, () => this.scene.game.canvas);
+    }
+    static create(scene, config) {
+      return new _PhaserSkillprintAdapter(scene, config);
+    }
+    startSession(targetMood, customPlayerId = null) {
+      return this.manager.startGameSession(targetMood, customPlayerId);
+    }
+    stopSession() {
+      this.manager.stopGameSession();
+    }
+    registerParameter(parameterName, updateAction, expectedType = null) {
+      this.manager.registerParameterModifier(parameterName, updateAction, expectedType);
+    }
+    /**
+     * Phaser-specific helper to register sprite property updates directly.
+     */
+    registerSpriteProperty(parameterName, sprite, propertyName) {
+      this.manager.registerParameterModifier(parameterName, (value) => {
+        sprite[propertyName] = value;
+      });
+    }
+  };
+
+  // src/adapters/three.ts
+  var ThreeSkillprintAdapter = class _ThreeSkillprintAdapter {
+    constructor(renderer, config) {
+      this.renderer = renderer;
+      this.config = config;
+      this.manager = new SkillprintManager(config, () => this.renderer.domElement);
+    }
+    static create(renderer, config) {
+      return new _ThreeSkillprintAdapter(renderer, config);
+    }
+    startSession(targetMood, customPlayerId = null) {
+      return this.manager.startGameSession(targetMood, customPlayerId);
+    }
+    stopSession() {
+      this.manager.stopGameSession();
+    }
+    registerParameter(parameterName, updateAction, expectedType = null) {
+      this.manager.registerParameterModifier(parameterName, updateAction, expectedType);
+    }
+    /**
+     * Three.js-specific helper to register object or nested material property updates.
+     */
+    registerObjectProperty(parameterName, object, propertyName) {
+      this.manager.registerParameterModifier(parameterName, (value) => {
+        if (propertyName.includes(".")) {
+          const props = propertyName.split(".");
+          let target = object;
+          for (let i = 0; i < props.length - 1; i++) {
+            target = target[props[i]];
+          }
+          target[props[props.length - 1]] = value;
+        } else {
+          object[propertyName] = value;
+        }
+      });
+    }
+  };
+
+  // src/adapters/pixi.ts
+  var PixiSkillprintAdapter = class _PixiSkillprintAdapter {
+    constructor(app, config) {
+      this.app = app;
+      this.config = config;
+      this.manager = new SkillprintManager(config, () => this.app.view || this.app.canvas || null);
+    }
+    static create(app, config) {
+      return new _PixiSkillprintAdapter(app, config);
+    }
+    startSession(targetMood, customPlayerId = null) {
+      return this.manager.startGameSession(targetMood, customPlayerId);
+    }
+    stopSession() {
+      this.manager.stopGameSession();
+    }
+    registerParameter(parameterName, updateAction, expectedType = null) {
+      this.manager.registerParameterModifier(parameterName, updateAction, expectedType);
+    }
+    /**
+     * PixiJS-specific helper to register display object property updates.
+     */
+    registerDisplayObjectProperty(parameterName, displayObject, propertyName) {
+      this.manager.registerParameterModifier(parameterName, (value) => {
+        displayObject[propertyName] = value;
+      });
+    }
+  };
+
+  // src/adapters/canvas.ts
+  var GenericCanvasSkillprintAdapter = class _GenericCanvasSkillprintAdapter {
+    constructor(canvas, config) {
+      this.canvas = canvas;
+      this.config = config;
+      this.manager = new SkillprintManager(config, () => this.canvas);
+    }
+    static create(canvas, config) {
+      return new _GenericCanvasSkillprintAdapter(canvas, config);
+    }
+    startSession(targetMood, customPlayerId = null) {
+      return this.manager.startGameSession(targetMood, customPlayerId);
+    }
+    stopSession() {
+      this.manager.stopGameSession();
+    }
+    registerParameter(parameterName, updateAction, expectedType = null) {
+      this.manager.registerParameterModifier(parameterName, updateAction, expectedType);
+    }
+  };
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map