@sockethub/server 5.0.0-alpha.14 → 5.0.0-alpha.16

package/dist/platform-instance.d.ts

@@ -47,6 +47,7 @@ export default class PlatformInstance {
     private heartbeatListener?;
     private heartbeatFailureHandled;
     private replaced;
+    private shutdownResult?;
     private readonly actor?;
     constructor(params: PlatformInstanceParams);
     createQueue(): void;
@@ -66,9 +67,17 @@ export default class PlatformInstance {
      */
     markReplaced(): void;
     /**
-     * Destroys all references to this platform instance, internal listeners and controlled processes
+     * Destroys all references to this platform instance, internal listeners and controlled processes.
+     *
+     * Single-flight: every caller shares one teardown run. A crash-close
+     * teardown pauses and obliterates the Redis queue asynchronously, so a
+     * caller about to create a replacement (ProcessManager.ensureProcess)
+     * must be able to await the teardown *already in flight* — a second,
+     * independent run would resolve while the first is still obliterating
+     * the queue name the replacement is about to reuse.
      */
     shutdown(): Promise<void>;
+    private teardown;
     /**
      * When jobs are completed or failed, we prepare the results and send them to the client socket
      */

package/dist/platform.js

@@ -19800,9 +19800,87 @@ var init_activity_stream = __esm(() => {
 // ../schemas/src/schemas/platform.ts
 var init_platform = () => {};
 
+// ../schemas/package.json
+var package_default;
+var init_package = __esm(() => {
+  package_default = {
+    name: "@sockethub/schemas",
+    description: "JSON schema files for validating Sockethub Activity Streams",
+    version: "3.0.0-alpha.16",
+    type: "module",
+    private: false,
+    author: "Nick Jennings <nick@silverbucket.net>",
+    license: "MIT",
+    publishConfig: {
+      access: "public"
+    },
+    main: "dist/index.js",
+    exports: {
+      ".": {
+        types: "./dist/index.d.ts",
+        import: "./dist/index.js",
+        default: "./dist/index.js"
+      },
+      "./context": {
+        types: "./dist/context.d.ts",
+        import: "./dist/context.js",
+        default: "./dist/context.js"
+      },
+      "./object-types": {
+        types: "./dist/object-types.d.ts",
+        import: "./dist/object-types.js",
+        default: "./dist/object-types.js"
+      },
+      "./schemas/json/sockethub-config.json": {
+        default: "./dist/schemas/json/sockethub-config.json"
+      }
+    },
+    files: [
+      "dist/"
+    ],
+    engines: {
+      node: ">=20"
+    },
+    keywords: [
+      "sockethub",
+      "sockethub schema",
+      "activity streams",
+      "activity objects",
+      "sockethub platforms"
+    ],
+    repository: {
+      type: "git",
+      url: "git+https://github.com/sockethub/sockethub.git",
+      directory: "packages/schemas"
+    },
+    homepage: "https://github.com/sockethub/sockethub/tree/master/packages/schemas",
+    devDependencies: {
+      "@types/bun": "latest"
+    },
+    scripts: {
+      build: "bun ./scripts/export-json-schema.ts && bun ./scripts/export-canonical-assets.ts && bun build src/index.ts src/object-types.ts --outdir dist --target node --format esm --sourcemap=external && bun build src/context.ts src/activity-stream-helper.ts --outdir dist --target browser --format esm --sourcemap=external",
+      clean: "rm -rf dist",
+      "clean:deps": "rm -rf node_modules"
+    },
+    dependencies: {
+      ajv: "^8.17.1",
+      "ajv-formats": "^2.1.1",
+      "ajv-formats-draft2019": "^1.6.1"
+    },
+    gitHead: "1a1a01ffe7b9d356aacfc4ae583d553e5df6f97d",
+    types: "./dist/index.d.ts"
+  };
+});
+
+// ../schemas/src/schema-id.ts
+function versionedSchemaId(id, version) {
+  return id.replace("/v/", `/${version}/`);
+}
+
 // ../schemas/src/schemas/sockethub-config.ts
-var SockethubConfigSchema;
+var SockethubConfigSchema, SockethubConfigSchemaId;
 var init_sockethub_config = __esm(() => {
+  init_package();
   SockethubConfigSchema = {
     $id: "https://sockethub.org/schemas/v/sockethub-config.json",
     description: "Sockethub Config Schema",
@@ -19815,11 +19893,13 @@ var init_sockethub_config = __esm(() => {
       },
       examples: {
         type: "boolean",
-        default: true
+        default: true,
+        description: "Enable the examples pages served at [host]:[port]/examples"
       },
       info: {
         type: "boolean",
-        default: false
+        default: false,
+        description: "Display Sockethub runtime information"
       },
       logging: {
         type: "object",
@@ -19846,6 +19926,7 @@ var init_sockethub_config = __esm(() => {
         items: {
           type: "string"
         },
+        description: "Platform packages to load",
         default: [
           "@sockethub/platform-dummy",
           "@sockethub/platform-feeds",
@@ -19856,6 +19937,8 @@ var init_sockethub_config = __esm(() => {
       },
       packageConfig: {
         type: "object",
+        default: {},
+        description: "Per-platform config keyed by package name, validated against " + "each platform's config schema and forwarded to its child process",
         properties: {
           "@sockethub/platform-dummy": {
             type: "object",
@@ -19965,7 +20048,8 @@ var init_sockethub_config = __esm(() => {
           maxConnectionsPerIp: {
             type: "number",
             minimum: 0,
-            default: 0
+            default: 0,
+            description: "Maximum concurrent socket connections per client IP. " + "The per-event rate limiter is keyed by socket id, so " + "without a connection cap a client can bypass it by " + "opening more sockets. 0 disables the cap."
           }
         }
       },
@@ -19976,7 +20060,8 @@ var init_sockethub_config = __esm(() => {
           maxPlatformInstances: {
             type: "number",
             minimum: 0,
-            default: 0
+            default: 0,
+            description: "Upper bound on concurrently running platform instances " + "(child processes). Each persistent-platform actor forks " + "its own process, so an unbounded count is a resource " + "exhaustion risk on public instances. 0 disables the cap."
           }
         }
       },
@@ -20041,7 +20126,8 @@ var init_sockethub_config = __esm(() => {
             properties: {
               origin: {
                 type: "string",
-                default: "*"
+                default: "*",
+                description: "Allowed CORS origin(s) for socket.io connections " + "and the HTTP actions endpoint. '*' allows any " + "website to connect visitors' browsers to this " + "instance; public deployments should set an " + "explicit origin or comma-separated list of " + "origins."
               }
             }
           }
@@ -20053,7 +20139,8 @@ var init_sockethub_config = __esm(() => {
         properties: {
           enabled: {
             type: "boolean",
-            default: false
+            default: false,
+            description: "Enable the HTTP actions endpoint"
           },
           path: {
             type: "string",
@@ -20106,6 +20193,7 @@ var init_sockethub_config = __esm(() => {
       }
     }
   };
+  SockethubConfigSchemaId = versionedSchemaId(SockethubConfigSchema.$id, package_default.version);
 });
 
 // ../../node_modules/ajv/dist/compile/codegen/code.js
@@ -69637,6 +69725,184 @@ var require_main = __commonJS((exports, module) => {
   module.exports = convict;
 });
 
+// src/config-schema.ts
+function isLeaf(node, overlay) {
+  if (overlay?.leaf) {
+    return true;
+  }
+  return !(node.type === "object" && node.properties);
+}
+function hasDefault(node, overlay) {
+  return Object.hasOwn(node, "default") || overlay !== undefined && Object.hasOwn(overlay, "default");
+}
+function defaultOf(node, overlay) {
+  const value = Object.hasOwn(node, "default") ? node.default : overlay?.default;
+  return value !== null && typeof value === "object" ? structuredClone(value) : value;
+}
+function convictFormat(node, path, overlay) {
+  if (overlay?.format !== undefined) {
+    return overlay.format;
+  }
+  if (Array.isArray(node.enum)) {
+    return [...node.enum];
+  }
+  if (Array.isArray(node.type)) {
+    return "*";
+  }
+  switch (node.type) {
+    case "boolean":
+      return Boolean;
+    case "string":
+      return String;
+    case "number":
+    case "integer":
+      return Number;
+    case "array":
+      return Array;
+    case "object":
+      return Object;
+    default:
+      throw new Error(`config schema: unsupported type "${node.type}" at "${path}"`);
+  }
+}
+function buildDefinition(node, overlays, consumed, prefix = "") {
+  const definition = {};
+  for (const [key, child] of Object.entries(node.properties ?? {})) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    const overlay = overlays[path];
+    if (overlay) {
+      consumed.add(path);
+    }
+    if (!isLeaf(child, overlay)) {
+      definition[key] = buildDefinition(child, overlays, consumed, path);
+      continue;
+    }
+    if (!hasDefault(child, overlay)) {
+      throw new Error(`config schema: no default declared for "${path}" in the ` + "JSON schema or its overlay entry");
+    }
+    const leaf = {
+      format: convictFormat(child, path, overlay),
+      default: defaultOf(child, overlay)
+    };
+    if (child.description) {
+      leaf.doc = child.description;
+    }
+    if (overlay?.env) {
+      leaf.env = overlay.env;
+    }
+    if (overlay?.arg) {
+      leaf.arg = overlay.arg;
+    }
+    definition[key] = leaf;
+  }
+  return definition;
+}
+function buildConvictDefinition(jsonSchema, overlays) {
+  const consumed = new Set;
+  const definition = buildDefinition(jsonSchema, overlays, consumed);
+  const unknown = Object.keys(overlays).filter((path) => !consumed.has(path));
+  if (unknown.length > 0) {
+    throw new Error("config schema: overlay entries reference paths missing from " + `the JSON schema: ${unknown.join(", ")}`);
+  }
+  return definition;
+}
+function buildSchema() {
+  return import_convict.default(buildConvictDefinition(SockethubConfigSchema, OVERLAY));
+}
+var import_convict, OVERLAY, EMPTY_ENV_IS_UNSET_VARS;
+var init_config_schema = __esm(() => {
+  init_src2();
+  import_convict = __toESM(require_main(), 1);
+  OVERLAY = {
+    $schema: { default: "" },
+    examples: { arg: "examples" },
+    info: { arg: "info" },
+    "logging.level": { env: "LOG_LEVEL", emptyEnvIsUnset: true },
+    "logging.fileLevel": { env: "LOG_FILE_LEVEL", emptyEnvIsUnset: true },
+    "logging.file": { env: "LOG_FILE", emptyEnvIsUnset: true },
+    packageConfig: { leaf: true, format: Object },
+    "public.port": { format: "port" },
+    "rateLimiter.windowMs": { format: "nat" },
+    "rateLimiter.maxRequests": { format: "nat" },
+    "rateLimiter.blockDurationMs": { format: "nat" },
+    "rateLimiter.maxConnectionsPerIp": { format: "nat" },
+    "limits.maxPlatformInstances": { format: "nat" },
+    "credentials.ttlMs": {
+      format: "nat",
+      env: "SOCKETHUB_CREDENTIALS_TTL_MS",
+      emptyEnvIsUnset: true
+    },
+    "redis.url": {
+      env: "REDIS_URL",
+      emptyEnvIsUnset: true,
+      arg: "redis.url"
+    },
+    "redis.connectTimeout": { format: "nat" },
+    "redis.disconnectTimeout": { format: "nat" },
+    "redis.maxRetriesPerRequest": { format: "*" },
+    "sentry.dsn": { arg: "sentry.dsn" },
+    "sockethub.port": {
+      format: "port",
+      env: "PORT",
+      emptyEnvIsUnset: true,
+      arg: "port"
+    },
+    "sockethub.host": { env: "HOST", emptyEnvIsUnset: true, arg: "host" },
+    "sockethub.cors.origin": {
+      env: "SOCKETHUB_CORS_ORIGIN",
+      arg: "cors.origin"
+    },
+    "httpActions.enabled": {
+      env: "SOCKETHUB_HTTP_ACTIONS_ENABLED",
+      emptyEnvIsUnset: true
+    },
+    "httpActions.path": {
+      env: "SOCKETHUB_HTTP_ACTIONS_PATH",
+      emptyEnvIsUnset: true
+    },
+    "httpActions.requireRequestId": {
+      env: "SOCKETHUB_HTTP_ACTIONS_REQUIRE_REQUEST_ID",
+      emptyEnvIsUnset: true
+    },
+    "httpActions.maxMessagesPerRequest": {
+      format: "nat",
+      env: "SOCKETHUB_HTTP_ACTIONS_MAX_MESSAGES_PER_REQUEST",
+      emptyEnvIsUnset: true
+    },
+    "httpActions.maxPayloadBytes": {
+      format: "nat",
+      env: "SOCKETHUB_HTTP_ACTIONS_MAX_PAYLOAD_BYTES",
+      emptyEnvIsUnset: true
+    },
+    "httpActions.idempotencyTtlMs": {
+      format: "nat",
+      env: "SOCKETHUB_HTTP_ACTIONS_IDEMPOTENCY_TTL_MS",
+      emptyEnvIsUnset: true
+    },
+    "httpActions.requestTimeoutMs": {
+      format: "nat",
+      env: "SOCKETHUB_HTTP_ACTIONS_REQUEST_TIMEOUT_MS",
+      emptyEnvIsUnset: true
+    },
+    "httpActions.idleTimeoutMs": {
+      format: "nat",
+      env: "SOCKETHUB_HTTP_ACTIONS_IDLE_TIMEOUT_MS",
+      emptyEnvIsUnset: true
+    },
+    "platformHeartbeat.intervalMs": {
+      format: "nat",
+      env: "SOCKETHUB_PLATFORM_HEARTBEAT_INTERVAL_MS",
+      emptyEnvIsUnset: true
+    },
+    "platformHeartbeat.timeoutMs": {
+      format: "nat",
+      env: "SOCKETHUB_PLATFORM_HEARTBEAT_TIMEOUT_MS",
+      emptyEnvIsUnset: true
+    }
+  };
+  EMPTY_ENV_IS_UNSET_VARS = Object.values(OVERLAY).filter((entry) => entry.emptyEnvIsUnset && entry.env).map((entry) => entry.env);
+});
+
 // src/logger-core.ts
 function createWinstonLogger(namespace, options = {}) {
   const cfg = {
@@ -69681,197 +69947,6 @@ var init_logger_core = __esm(() => {
 // src/config.ts
 import fs from "node:fs";
 import path from "node:path";
-function buildSchema() {
-  return import_convict.default({
-    $schema: { format: String, default: "" },
-    examples: {
-      doc: "Enable the examples pages served at [host]:[port]/examples",
-      format: Boolean,
-      default: true,
-      arg: "examples"
-    },
-    info: {
-      doc: "Display Sockethub runtime information",
-      format: Boolean,
-      default: false,
-      arg: "info"
-    },
-    logging: {
-      level: {
-        format: LOG_LEVELS,
-        default: "info",
-        env: "LOG_LEVEL"
-      },
-      fileLevel: {
-        format: LOG_LEVELS,
-        default: "debug",
-        env: "LOG_FILE_LEVEL"
-      },
-      file: {
-        format: String,
-        default: "sockethub.log",
-        env: "LOG_FILE"
-      }
-    },
-    platforms: {
-      doc: "Platform packages to load",
-      format: Array,
-      default: [
-        "@sockethub/platform-dummy",
-        "@sockethub/platform-feeds",
-        "@sockethub/platform-irc",
-        "@sockethub/platform-metadata",
-        "@sockethub/platform-xmpp"
-      ]
-    },
-    packageConfig: {
-      doc: "Per-platform config keyed by package name, validated against " + "each platform's config schema and forwarded to its child process",
-      format: Object,
-      default: {}
-    },
-    public: {
-      protocol: { format: String, default: "http" },
-      host: { format: String, default: "localhost" },
-      port: { format: "port", default: 10550 },
-      path: { format: String, default: "/" }
-    },
-    rateLimiter: {
-      windowMs: { format: "nat", default: 1000 },
-      maxRequests: { format: "nat", default: 100 },
-      blockDurationMs: { format: "nat", default: 5000 },
-      maxConnectionsPerIp: {
-        doc: "Maximum concurrent socket connections per client IP. " + "The per-event rate limiter is keyed by socket id, so " + "without a connection cap a client can bypass it by " + "opening more sockets. 0 disables the cap.",
-        format: "nat",
-        default: 0
-      }
-    },
-    limits: {
-      maxPlatformInstances: {
-        doc: "Upper bound on concurrently running platform instances " + "(child processes). Each persistent-platform actor forks " + "its own process, so an unbounded count is a resource " + "exhaustion risk on public instances. 0 disables the cap.",
-        format: "nat",
-        default: 0
-      }
-    },
-    credentials: {
-      ttlMs: {
-        doc: "Sliding TTL in milliseconds for per-session encrypted " + "credential keys in Redis, refreshed on every save and " + "read. A backstop against keys orphaned by crashes; " + "sessions normally delete their key on disconnect. " + "Size generously — idle sessions do not refresh it. " + "0 disables expiry.",
-        format: "nat",
-        default: 604800000,
-        env: "SOCKETHUB_CREDENTIALS_TTL_MS"
-      }
-    },
-    credentialCheck: {
-      reconnectIpSource: {
-        format: ["socket", "proxy"],
-        default: "socket"
-      },
-      proxyHeader: { format: String, default: "x-forwarded-for" }
-    },
-    redis: {
-      url: {
-        format: String,
-        default: "redis://127.0.0.1:6379",
-        env: "REDIS_URL",
-        arg: "redis.url"
-      },
-      connectTimeout: {
-        format: "nat",
-        default: 1e4,
-        doc: "Connection timeout in milliseconds"
-      },
-      disconnectTimeout: {
-        format: "nat",
-        default: 5000,
-        doc: "Disconnect timeout in milliseconds"
-      },
-      maxRetriesPerRequest: {
-        format: "*",
-        default: null
-      }
-    },
-    sentry: {
-      dsn: { format: String, default: "", arg: "sentry.dsn" },
-      traceSampleRate: { format: Number, default: 1 }
-    },
-    sockethub: {
-      port: {
-        format: "port",
-        default: 10550,
-        env: "PORT",
-        arg: "port"
-      },
-      host: {
-        format: String,
-        default: "localhost",
-        env: "HOST",
-        arg: "host"
-      },
-      path: { format: String, default: "/sockethub" },
-      cors: {
-        origin: {
-          doc: "Allowed CORS origin(s) for socket.io connections. " + "'*' allows any website to connect visitors' " + "browsers to this instance; public deployments " + "should set an explicit origin or comma-separated " + "list of origins.",
-          format: String,
-          default: "*"
-        }
-      }
-    },
-    httpActions: {
-      enabled: {
-        doc: "Enable the HTTP actions endpoint",
-        format: Boolean,
-        default: false,
-        env: "SOCKETHUB_HTTP_ACTIONS_ENABLED"
-      },
-      path: {
-        format: String,
-        default: "/sockethub-http",
-        env: "SOCKETHUB_HTTP_ACTIONS_PATH"
-      },
-      requireRequestId: {
-        format: Boolean,
-        default: true,
-        env: "SOCKETHUB_HTTP_ACTIONS_REQUIRE_REQUEST_ID"
-      },
-      maxMessagesPerRequest: {
-        format: "nat",
-        default: 20,
-        env: "SOCKETHUB_HTTP_ACTIONS_MAX_MESSAGES_PER_REQUEST"
-      },
-      maxPayloadBytes: {
-        format: "nat",
-        default: 262144,
-        env: "SOCKETHUB_HTTP_ACTIONS_MAX_PAYLOAD_BYTES"
-      },
-      idempotencyTtlMs: {
-        format: "nat",
-        default: 300000,
-        env: "SOCKETHUB_HTTP_ACTIONS_IDEMPOTENCY_TTL_MS"
-      },
-      requestTimeoutMs: {
-        format: "nat",
-        default: 30000,
-        env: "SOCKETHUB_HTTP_ACTIONS_REQUEST_TIMEOUT_MS"
-      },
-      idleTimeoutMs: {
-        format: "nat",
-        default: 15000,
-        env: "SOCKETHUB_HTTP_ACTIONS_IDLE_TIMEOUT_MS"
-      }
-    },
-    platformHeartbeat: {
-      intervalMs: {
-        format: "nat",
-        default: 5000,
-        env: "SOCKETHUB_PLATFORM_HEARTBEAT_INTERVAL_MS"
-      },
-      timeoutMs: {
-        format: "nat",
-        default: 15000,
-        env: "SOCKETHUB_PLATFORM_HEARTBEAT_TIMEOUT_MS"
-      }
-    }
-  });
-}
 function resolveConfigFile() {
   const argv = process.argv.slice(2);
   for (let i = 0;i < argv.length; i++) {
@@ -69905,7 +69980,7 @@ class Config {
       level: "info"
     });
     this.log.debug("initializing config");
-    for (const name of MAPPED_ENV_VARS) {
+    for (const name of EMPTY_ENV_IS_UNSET_VARS) {
       if (process.env[name] === "") {
         delete process.env[name];
       }
@@ -69934,31 +70009,11 @@ class Config {
     return this.conf.get(path2);
   };
 }
-var import_convict, defaultConfig = "sockethub.config.json", MAPPED_ENV_VARS, LOG_LEVELS, config, config_default;
+var defaultConfig = "sockethub.config.json", config, config_default;
 var init_config = __esm(() => {
   init_src2();
+  init_config_schema();
   init_logger_core();
-  import_convict = __toESM(require_main(), 1);
-  MAPPED_ENV_VARS = [
-    "HOST",
-    "PORT",
-    "REDIS_URL",
-    "LOG_LEVEL",
-    "LOG_FILE_LEVEL",
-    "LOG_FILE",
-    "SOCKETHUB_PLATFORM_HEARTBEAT_INTERVAL_MS",
-    "SOCKETHUB_PLATFORM_HEARTBEAT_TIMEOUT_MS",
-    "SOCKETHUB_HTTP_ACTIONS_ENABLED",
-    "SOCKETHUB_HTTP_ACTIONS_PATH",
-    "SOCKETHUB_HTTP_ACTIONS_REQUIRE_REQUEST_ID",
-    "SOCKETHUB_HTTP_ACTIONS_MAX_MESSAGES_PER_REQUEST",
-    "SOCKETHUB_HTTP_ACTIONS_MAX_PAYLOAD_BYTES",
-    "SOCKETHUB_HTTP_ACTIONS_IDEMPOTENCY_TTL_MS",
-    "SOCKETHUB_HTTP_ACTIONS_REQUEST_TIMEOUT_MS",
-    "SOCKETHUB_HTTP_ACTIONS_IDLE_TIMEOUT_MS",
-    "SOCKETHUB_CREDENTIALS_TTL_MS"
-  ];
-  LOG_LEVELS = ["error", "warn", "info", "debug"];
   config = new Config;
   config_default = config;
 });
@@ -103001,7 +103056,7 @@ function isPromiseLike(value) {
 function shouldIgnoreSpan2(spanName, ignoreSpanTypes) {
   return ignoreSpanTypes.some((pattern) => typeof pattern === "string" ? pattern === spanName : pattern.test(spanName));
 }
-var import_api17, import_instrumentation9, import_api18, package_default, majorVersion, GLOBAL_INSTRUMENTATION_KEY = "PRISMA_INSTRUMENTATION", GLOBAL_VERSIONED_INSTRUMENTATION_KEY, globalThisWithPrismaInstrumentation, showAllTraces, nonSampledTraceParent = `00-10-10-00`, ActiveTracingHelper = class {
+var import_api17, import_instrumentation9, import_api18, package_default2, majorVersion, GLOBAL_INSTRUMENTATION_KEY = "PRISMA_INSTRUMENTATION", GLOBAL_VERSIONED_INSTRUMENTATION_KEY, globalThisWithPrismaInstrumentation, showAllTraces, nonSampledTraceParent = `00-10-10-00`, ActiveTracingHelper = class {
   tracerProvider;
   ignoreSpanTypes;
   constructor({ tracerProvider, ignoreSpanTypes }) {
@@ -103048,12 +103103,12 @@ var import_api17, import_instrumentation9, import_api18, package_default, majorV
     }
     return tracer.startActiveSpan(name, options, (span) => endSpan2(span, callback(span, context10)));
   }
-}, package_default2, VERSION, NAME, MODULE_NAME = "@prisma/client", PrismaInstrumentation;
+}, package_default22, VERSION, NAME, MODULE_NAME = "@prisma/client", PrismaInstrumentation;
 var init_dist = __esm(() => {
   import_api17 = __toESM(require_src4(), 1);
   import_instrumentation9 = __toESM(require_src28(), 1);
   import_api18 = __toESM(require_src4(), 1);
-  package_default = {
+  package_default2 = {
     name: "@prisma/instrumentation-contract",
     version: "7.2.0",
     description: "Shared types and utilities for Prisma instrumentation",
@@ -103097,11 +103152,11 @@ var init_dist = __esm(() => {
       "@opentelemetry/api": "^1.8"
     }
   };
-  majorVersion = package_default.version.split(".")[0];
+  majorVersion = package_default2.version.split(".")[0];
   GLOBAL_VERSIONED_INSTRUMENTATION_KEY = `V${majorVersion}_PRISMA_INSTRUMENTATION`;
   globalThisWithPrismaInstrumentation = globalThis;
   showAllTraces = process.env.PRISMA_SHOW_ALL_TRACES === "true";
-  package_default2 = {
+  package_default22 = {
     name: "@prisma/instrumentation",
     version: "7.2.0",
     description: "OpenTelemetry compliant instrumentation for Prisma Client",
@@ -103157,8 +103212,8 @@ var init_dist = __esm(() => {
     },
     sideEffects: false
   };
-  VERSION = package_default2.version;
-  NAME = package_default2.name;
+  VERSION = package_default22.version;
+  NAME = package_default22.name;
   PrismaInstrumentation = class extends import_instrumentation9.InstrumentationBase {
     tracerProvider;
     constructor(config2 = {}) {
@@ -128439,4 +128494,4 @@ export {
   derivePlatformCredentialsSecret
 };
 
-//# debugId=D04C26E0AE9C534764756E2164756E21
+//# debugId=D2C58EBF7939E3F364756E2164756E21