failproofai 1.0.11 → 1.0.12-beta.1

package/.next/standalone/fp-cloud-cli/tests/test_enforcement_logic.py

@@ -141,6 +141,52 @@ def test_set_replaces_the_whole_set():
     assert plan.result[0].version == 5
 
 
+def test_agent_targets_round_trip_and_survive_an_unrelated_add():
+    scoped = PolicyRef.from_dict({
+        "id": "guard", "version": 2, "effect": "enforce",
+        "agentTargets": [{"integration": "hermes", "instanceId": "agt_1234567890abcdef"}],
+    })
+    assert scoped.to_dict()["agentTargets"] == [
+        {"integration": "hermes", "instanceId": "agt_1234567890abcdef"},
+    ]
+    plan = plan_deploy("machine", current=[scoped], base=2, add=["guard@3"], latest={"guard": 3})
+    assert plan.result[0].agent_targets == scoped.agent_targets
+    assert plan.result[0].version == 3
+    assert scoped.version == 2
+
+
+def test_target_changes_are_a_diff_and_clearing_is_explicit():
+    initial = ref("guard")
+    narrowed = plan_deploy(
+        "machine", current=[initial], base=1,
+        targets=["guard=hermes/agt_1234567890abcdef", "guard=codex"],
+    )
+    assert narrowed.changed == [(initial, narrowed.result[0])]
+    assert narrowed.result[0].agent_targets == [
+        {"integration": "hermes", "instanceId": "agt_1234567890abcdef"},
+        {"integration": "codex"},
+    ]
+    cleared = plan_deploy(
+        "machine", current=narrowed.result, base=2, all_agents=["guard"],
+    )
+    assert cleared.result[0].agent_targets is None
+    assert cleared.set_changes
+
+
+@pytest.mark.parametrize("targets,clears", [
+    (["guard=stranger"], []),
+    (["guard=hermes/bad"], []),
+    (["guard=hermes", "guard=hermes"], []),
+    (["guard=hermes"], ["guard"]),
+    (["missing=codex"], []),
+    (["guard@1=codex"], []),
+])
+def test_invalid_agent_target_request_cannot_write(targets, clears):
+    with pytest.raises(RefError):
+        plan_deploy("machine", current=[ref("guard")], base=1,
+                    targets=targets, all_agents=clears)
+
+
 def test_set_cannot_be_mixed_with_add_or_remove():
     """"exactly these" and "these as well" have no single reading."""
     with pytest.raises(RefError, match="cannot be combined"):

package/.next/standalone/fp-cloud-cli/tests/test_output.py

@@ -1590,6 +1590,29 @@ def test_history_says_no_change_only_when_nothing_moved(capsys):
     assert "no change" in capsys.readouterr().out
 
 
+def test_history_keeps_gen_when_and_jev_on_an_80_column_terminal(capsys):
+    """At 80 columns every no_wrap cell got shaved at once and `gen`, `when` and
+    `jev` vanished — but `gen` is what `fp fleet rollback` takes."""
+    _wide_stdout(80)
+    pols = [{"id": f"long-policy-name-{i:02d}", "version": 1, "effect": "enforce",
+             "agentTargets": [{"integration": "claude", "instanceId": "agt_" + "ab" * 16}]}
+            for i in range(4)]
+    entries = [{"deployment": g, "updatedAt": f"2026-08-{10 + g:02d}T13:49:00Z",
+                "jevMode": "observe" if g % 2 else None, "policies": pols[:g]}
+               for g in range(1, 5)]
+    output.render_deployment_history("m", entries)
+    out = capsys.readouterr().out
+    assert max(len(ln) for ln in out.splitlines()) <= 80
+    header = next(ln for ln in out.splitlines() if "change" in ln)
+    for col in ("gen", "when", "jev"):
+        assert col in header, (col, out)
+    for g in range(1, 5):
+        row = next((ln for ln in out.splitlines() if f"#{g} " in ln), None)
+        assert row is not None, (g, out)
+        assert f"08-{10 + g:02d} 13:49:00" in row, out
+        assert ("observe" if g % 2 else "local") in row, out
+
+
 def test_clearing_a_label_is_not_reported_as_renaming_to_blank(capsys):
     """`fp fleet rename m ""` clears the override server-side, and the card
     said `labelled m as ` — a sentence with a hole in it, describing neither

package/.next/standalone/fp-cloud-cli/uv.lock

@@ -36,11 +36,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.7.22"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -372,7 +372,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.67.0"
+version = "7.71.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "backoff" },
@@ -380,9 +380,9 @@ dependencies = [
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/34/1d/bb4b6538c94b63c32bbe32a4782393ae0560d49f9517f51b04fe3e970d4a/posthog-7.67.0.tar.gz", hash = "sha256:37feb3c125f067ca077800dd986a5a9f1d264a3d92d75ca3061047c4db93565e", size = 751479, upload-time = "2026-10-09T09:33:04.975Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c6/9b/12e2e82fbbf5d70f554cfd1930631a6d1cce8975721ad50b5d7b47e580ff/posthog-7.71.0.tar.gz", hash = "sha256:00950999edf7f613a90015126bacc431d3ab3964a70d91c2f792e6a0dc81f358", size = 763019, upload-time = "2026-10-16T19:24:33.765Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8e/57/9ff310d3e7f141bc6900ad1befb493bcd48f7b7934a825f4b523c33ebc09/posthog-7.67.0-py3-none-any.whl", hash = "sha256:88ebf5810f83f338f400ab15743640548f0585075687bc9166bc2f1e3fcf036f", size = 879016, upload-time = "2026-10-09T09:33:02.916Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/8e/9b185e665800a922e95fb965fb9c17d2a54cee575cf5e425308250663393/posthog-7.71.0-py3-none-any.whl", hash = "sha256:52cb1320b7e178b36ef7594cf15b4a8c492c24d4d1c46700f5bee0089ba5c6ac", size = 892234, upload-time = "2026-10-16T19:24:31.706Z" },
 ]
 
 [[package]]

package/.next/standalone/hermes-plugin/README.md

@@ -165,23 +165,25 @@ decision, because otherwise corrupted retry state could block a turn forever.
 ## Local protocol
 
 Requests and responses use the existing length-prefixed failproofaid Unix
-socket protocol, version 1.
+socket protocol, version 2. A v1 daemon must be upgraded before it can safely
+evaluate agent/profile-scoped policies.
 
 ```json
 {
   "type": "policyEvaluation",
-  "protocolVersion": 1,
+  "protocolVersion": 2,
   "integration": "hermes",
   "event": "pre_tool_call",
   "payload": {},
-  "cwd": "/workspace/project"
+  "cwd": "/workspace/project",
+  "agentSettingsPath": "/path/to/the/hermes/profile"
 }
 ```
 
 ```json
 {
   "type": "policyResult",
-  "protocolVersion": 1,
+  "protocolVersion": 2,
   "decision": "instruct",
   "policyNames": ["custom/approved-write-route"],
   "reason": "Use the approved write route.",

package/.next/standalone/hermes-plugin/__init__.py

@@ -102,6 +102,21 @@ def _profile_name() -> str:
     return "default"
 
 
+def _profile_settings_path(profile: str) -> str | None:
+    """Evidence of the profile running this plugin, not a transcript guess."""
+    configured = os.environ.get("HERMES_HOME", "").strip()
+    if configured:
+        selected = Path(configured).expanduser() / "config.yaml"
+    elif profile == "default":
+        selected = Path.home() / ".hermes" / "config.yaml"
+    elif re.fullmatch(r"[A-Za-z0-9._-]{1,80}", profile):
+        selected = Path.home() / ".hermes" / "profiles" / profile / "config.yaml"
+    else:
+        return None
+    # An unresolvable profile does not acquire some other profile's ID.
+    return str(selected.absolute()) if selected.is_file() else None
+
+
 def _string(value: object) -> str:
     return value if isinstance(value, str) else ""
 
@@ -660,6 +675,7 @@ class FailproofAIPlugin:
             event=event,
             payload=payload,
             cwd=cwd,
+            agent_settings_path=_profile_settings_path(self.profile),
             connect_timeout_ms=self.connect_timeout_ms,
             evaluation_timeout_ms=timeout_ms or self.evaluation_timeout_ms,
         )

package/.next/standalone/hermes-plugin/client.py

@@ -11,7 +11,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 
-PROTOCOL_VERSION = 1
+PROTOCOL_VERSION = 2
 MAX_FRAME_BYTES = 16 * 1024 * 1024
 MAX_REQUEST_BYTES = 1024 * 1024
 
@@ -75,6 +75,7 @@ def evaluate_policy(
     event: str,
     payload: Mapping[str, Any],
     cwd: str | None,
+    agent_settings_path: str | None = None,
     connect_timeout_ms: int = 250,
     evaluation_timeout_ms: int = 12_000,
 ) -> PolicyVerdict:
@@ -85,6 +86,9 @@ def evaluate_policy(
         "event": event,
         "payload": dict(payload),
         "cwd": cwd,
+        # An unknown profile is explicit. Omitting this field would let a new
+        # daemon's warm worker attribute the call to its own Hermes home.
+        "agentSettingsPath": agent_settings_path or "",
     }
     try:
         body = json.dumps(

package/.next/standalone/hermes-plugin/plugin.yaml

@@ -1,5 +1,5 @@
 name: failproofai
-version: 1.0.11
+version: 1.0.12-beta.1
 description: Real-time FailproofAI policy enforcement for Hermes
 manifest_version: 2
 api_version: 1

package/.next/standalone/node_modules/@next/env/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next/env",
-  "version": "16.4.0",
+  "version": "16.4.2",
   "keywords": [
     "react",
     "next",

package/.next/standalone/node_modules/@opentelemetry/api/build/src/api/context.js

@@ -0,0 +1,72 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextAPI = void 0;
+const NoopContextManager_1 = require("../context/NoopContextManager");
+const global_utils_1 = require("../internal/global-utils");
+const diag_1 = require("./diag");
+const API_NAME = 'context';
+const NOOP_CONTEXT_MANAGER = new NoopContextManager_1.NoopContextManager();
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry Context API
+ *
+ * @since 1.0.0
+ */
+class ContextAPI {
+    /** Empty private constructor prevents end users from constructing a new instance of the API */
+    constructor() { }
+    /** Get the singleton instance of the Context API */
+    static getInstance() {
+        if (!this._instance) {
+            this._instance = new ContextAPI();
+        }
+        return this._instance;
+    }
+    /**
+     * Set the current context manager.
+     *
+     * @returns true if the context manager was successfully registered, else false
+     */
+    setGlobalContextManager(contextManager) {
+        return (0, global_utils_1.registerGlobal)(API_NAME, contextManager, diag_1.DiagAPI.instance());
+    }
+    /**
+     * Get the currently active context
+     */
+    active() {
+        return this._getContextManager().active();
+    }
+    /**
+     * Execute a function with an active context
+     *
+     * @param context context to be active during function execution
+     * @param fn function to execute in a context
+     * @param thisArg optional receiver to be used for calling fn
+     * @param args optional arguments forwarded to fn
+     */
+    with(context, fn, thisArg, ...args) {
+        return this._getContextManager().with(context, fn, thisArg, ...args);
+    }
+    /**
+     * Bind a context to a target function or event emitter
+     *
+     * @param context context to bind to the event emitter or function. Defaults to the currently active context
+     * @param target function or event emitter to bind
+     */
+    bind(context, target) {
+        return this._getContextManager().bind(context, target);
+    }
+    _getContextManager() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_CONTEXT_MANAGER;
+    }
+    /** Disable and remove the global context manager */
+    disable() {
+        this._getContextManager().disable();
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+    }
+}
+exports.ContextAPI = ContextAPI;
+//# sourceMappingURL=context.js.map

package/.next/standalone/node_modules/@opentelemetry/api/build/src/api/diag.js

@@ -0,0 +1,84 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagAPI = void 0;
+const ComponentLogger_1 = require("../diag/ComponentLogger");
+const logLevelLogger_1 = require("../diag/internal/logLevelLogger");
+const types_1 = require("../diag/types");
+const global_utils_1 = require("../internal/global-utils");
+const API_NAME = 'diag';
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry internal
+ * diagnostic API
+ *
+ * @since 1.0.0
+ */
+class DiagAPI {
+    /** Get the singleton instance of the DiagAPI API */
+    static instance() {
+        if (!this._instance) {
+            this._instance = new DiagAPI();
+        }
+        return this._instance;
+    }
+    /**
+     * Private internal constructor
+     * @private
+     */
+    constructor() {
+        function _logProxy(funcName) {
+            return function (...args) {
+                const logger = (0, global_utils_1.getGlobal)('diag');
+                // shortcut if logger not set
+                if (!logger)
+                    return;
+                return logger[funcName](...args);
+            };
+        }
+        // Using self local variable for minification purposes as 'this' cannot be minified
+        const self = this;
+        // DiagAPI specific functions
+        const setLogger = (logger, optionsOrLogLevel = { logLevel: types_1.DiagLogLevel.INFO }) => {
+            var _a, _b, _c;
+            if (logger === self) {
+                // There isn't much we can do here.
+                // Logging to the console might break the user application.
+                // Try to log to self. If a logger was previously registered it will receive the log.
+                const err = new Error('Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation');
+                self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+                return false;
+            }
+            if (typeof optionsOrLogLevel === 'number') {
+                optionsOrLogLevel = {
+                    logLevel: optionsOrLogLevel,
+                };
+            }
+            const oldLogger = (0, global_utils_1.getGlobal)('diag');
+            const newLogger = (0, logLevelLogger_1.createLogLevelDiagLogger)((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : types_1.DiagLogLevel.INFO, logger);
+            // There already is an logger registered. We'll let it know before overwriting it.
+            if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+                const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : '<failed to generate stacktrace>';
+                oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+                newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
+            }
+            return (0, global_utils_1.registerGlobal)('diag', newLogger, self, true);
+        };
+        self.setLogger = setLogger;
+        self.disable = () => {
+            (0, global_utils_1.unregisterGlobal)(API_NAME, self);
+        };
+        self.createComponentLogger = (options) => {
+            return new ComponentLogger_1.DiagComponentLogger(options);
+        };
+        self.verbose = _logProxy('verbose');
+        self.debug = _logProxy('debug');
+        self.info = _logProxy('info');
+        self.warn = _logProxy('warn');
+        self.error = _logProxy('error');
+    }
+}
+exports.DiagAPI = DiagAPI;
+//# sourceMappingURL=diag.js.map

package/.next/standalone/node_modules/@opentelemetry/api/build/src/api/metrics.js

@@ -0,0 +1,50 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsAPI = void 0;
+const NoopMeterProvider_1 = require("../metrics/NoopMeterProvider");
+const global_utils_1 = require("../internal/global-utils");
+const diag_1 = require("./diag");
+const API_NAME = 'metrics';
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry Metrics API
+ */
+class MetricsAPI {
+    /** Empty private constructor prevents end users from constructing a new instance of the API */
+    constructor() { }
+    /** Get the singleton instance of the Metrics API */
+    static getInstance() {
+        if (!this._instance) {
+            this._instance = new MetricsAPI();
+        }
+        return this._instance;
+    }
+    /**
+     * Set the current global meter provider.
+     * Returns true if the meter provider was successfully registered, else false.
+     */
+    setGlobalMeterProvider(provider) {
+        return (0, global_utils_1.registerGlobal)(API_NAME, provider, diag_1.DiagAPI.instance());
+    }
+    /**
+     * Returns the global meter provider.
+     */
+    getMeterProvider() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || NoopMeterProvider_1.NOOP_METER_PROVIDER;
+    }
+    /**
+     * Returns a meter from the global meter provider.
+     */
+    getMeter(name, version, options) {
+        return this.getMeterProvider().getMeter(name, version, options);
+    }
+    /** Remove the global meter provider */
+    disable() {
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+    }
+}
+exports.MetricsAPI = MetricsAPI;
+//# sourceMappingURL=metrics.js.map

package/.next/standalone/node_modules/@opentelemetry/api/build/src/api/propagation.js

@@ -0,0 +1,80 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropagationAPI = void 0;
+const global_utils_1 = require("../internal/global-utils");
+const NoopTextMapPropagator_1 = require("../propagation/NoopTextMapPropagator");
+const TextMapPropagator_1 = require("../propagation/TextMapPropagator");
+const context_helpers_1 = require("../baggage/context-helpers");
+const utils_1 = require("../baggage/utils");
+const diag_1 = require("./diag");
+const API_NAME = 'propagation';
+const NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator_1.NoopTextMapPropagator();
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry Propagation API
+ *
+ * @since 1.0.0
+ */
+class PropagationAPI {
+    /** Empty private constructor prevents end users from constructing a new instance of the API */
+    constructor() {
+        this.createBaggage = utils_1.createBaggage;
+        this.getBaggage = context_helpers_1.getBaggage;
+        this.getActiveBaggage = context_helpers_1.getActiveBaggage;
+        this.setBaggage = context_helpers_1.setBaggage;
+        this.deleteBaggage = context_helpers_1.deleteBaggage;
+    }
+    /** Get the singleton instance of the Propagator API */
+    static getInstance() {
+        if (!this._instance) {
+            this._instance = new PropagationAPI();
+        }
+        return this._instance;
+    }
+    /**
+     * Set the current propagator.
+     *
+     * @returns true if the propagator was successfully registered, else false
+     */
+    setGlobalPropagator(propagator) {
+        return (0, global_utils_1.registerGlobal)(API_NAME, propagator, diag_1.DiagAPI.instance());
+    }
+    /**
+     * Inject context into a carrier to be propagated inter-process
+     *
+     * @param context Context carrying tracing data to inject
+     * @param carrier carrier to inject context into
+     * @param setter Function used to set values on the carrier
+     */
+    inject(context, carrier, setter = TextMapPropagator_1.defaultTextMapSetter) {
+        return this._getGlobalPropagator().inject(context, carrier, setter);
+    }
+    /**
+     * Extract context from a carrier
+     *
+     * @param context Context which the newly created context will inherit from
+     * @param carrier Carrier to extract context from
+     * @param getter Function used to extract keys from a carrier
+     */
+    extract(context, carrier, getter = TextMapPropagator_1.defaultTextMapGetter) {
+        return this._getGlobalPropagator().extract(context, carrier, getter);
+    }
+    /**
+     * Return a list of all fields which may be used by the propagator.
+     */
+    fields() {
+        return this._getGlobalPropagator().fields();
+    }
+    /** Remove the global propagator */
+    disable() {
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+    }
+    _getGlobalPropagator() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR;
+    }
+}
+exports.PropagationAPI = PropagationAPI;
+//# sourceMappingURL=propagation.js.map

package/.next/standalone/node_modules/@opentelemetry/api/build/src/api/trace.js

@@ -0,0 +1,70 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceAPI = void 0;
+const global_utils_1 = require("../internal/global-utils");
+const ProxyTracerProvider_1 = require("../trace/ProxyTracerProvider");
+const spancontext_utils_1 = require("../trace/spancontext-utils");
+const context_utils_1 = require("../trace/context-utils");
+const diag_1 = require("./diag");
+const API_NAME = 'trace';
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry Tracing API
+ *
+ * @since 1.0.0
+ */
+class TraceAPI {
+    /** Empty private constructor prevents end users from constructing a new instance of the API */
+    constructor() {
+        this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider();
+        this.wrapSpanContext = spancontext_utils_1.wrapSpanContext;
+        this.isSpanContextValid = spancontext_utils_1.isSpanContextValid;
+        this.deleteSpan = context_utils_1.deleteSpan;
+        this.getSpan = context_utils_1.getSpan;
+        this.getActiveSpan = context_utils_1.getActiveSpan;
+        this.getSpanContext = context_utils_1.getSpanContext;
+        this.setSpan = context_utils_1.setSpan;
+        this.setSpanContext = context_utils_1.setSpanContext;
+    }
+    /** Get the singleton instance of the Trace API */
+    static getInstance() {
+        if (!this._instance) {
+            this._instance = new TraceAPI();
+        }
+        return this._instance;
+    }
+    /**
+     * Set the current global tracer.
+     *
+     * @returns true if the tracer provider was successfully registered, else false
+     */
+    setGlobalTracerProvider(provider) {
+        const success = (0, global_utils_1.registerGlobal)(API_NAME, this._proxyTracerProvider, diag_1.DiagAPI.instance());
+        if (success) {
+            this._proxyTracerProvider.setDelegate(provider);
+        }
+        return success;
+    }
+    /**
+     * Returns the global tracer provider.
+     */
+    getTracerProvider() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || this._proxyTracerProvider;
+    }
+    /**
+     * Returns a tracer from the global tracer provider.
+     */
+    getTracer(name, version) {
+        return this.getTracerProvider().getTracer(name, version);
+    }
+    /** Remove the global tracer provider */
+    disable() {
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+        this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider();
+    }
+}
+exports.TraceAPI = TraceAPI;
+//# sourceMappingURL=trace.js.map

package/.next/standalone/node_modules/@opentelemetry/api/build/src/baggage/context-helpers.js

@@ -0,0 +1,52 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteBaggage = exports.setBaggage = exports.getActiveBaggage = exports.getBaggage = void 0;
+const context_1 = require("../api/context");
+const context_2 = require("../context/context");
+/**
+ * Baggage key
+ */
+const BAGGAGE_KEY = (0, context_2.createContextKey)('OpenTelemetry Baggage Key');
+/**
+ * Retrieve the current baggage from the given context
+ *
+ * @param {Context} Context that manage all context values
+ * @returns {Baggage} Extracted baggage from the context
+ */
+function getBaggage(context) {
+    return context.getValue(BAGGAGE_KEY) || undefined;
+}
+exports.getBaggage = getBaggage;
+/**
+ * Retrieve the current baggage from the active/current context
+ *
+ * @returns {Baggage} Extracted baggage from the context
+ */
+function getActiveBaggage() {
+    return getBaggage(context_1.ContextAPI.getInstance().active());
+}
+exports.getActiveBaggage = getActiveBaggage;
+/**
+ * Store a baggage in the given context
+ *
+ * @param {Context} Context that manage all context values
+ * @param {Baggage} baggage that will be set in the actual context
+ */
+function setBaggage(context, baggage) {
+    return context.setValue(BAGGAGE_KEY, baggage);
+}
+exports.setBaggage = setBaggage;
+/**
+ * Delete the baggage stored in the given context
+ *
+ * @param {Context} Context that manage all context values
+ */
+function deleteBaggage(context) {
+    return context.deleteValue(BAGGAGE_KEY);
+}
+exports.deleteBaggage = deleteBaggage;
+//# sourceMappingURL=context-helpers.js.map